1371 files changed, 47525 insertions, 177288 deletions

diff --git a/sources/pyside-tools/CMakeLists.txt b/sources/pyside-tools/CMakeLists.txt
index 0853b9ed4..e629ec570 100644
--- a/sources/pyside-tools/CMakeLists.txt
+++ b/sources/pyside-tools/CMakeLists.txt
@@ -1,65 +1,87 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 cmake_minimum_required(VERSION 3.18)
 project(pyside-tools)
 
 include(cmake/PySideToolsSetup.cmake)
 
-set(files ${CMAKE_CURRENT_SOURCE_DIR}/pyside_tool.py
-          ${CMAKE_CURRENT_SOURCE_DIR}/metaobjectdump.py
-          ${CMAKE_CURRENT_SOURCE_DIR}/project.py
-          ${CMAKE_CURRENT_SOURCE_DIR}/qml.py
-          ${CMAKE_CURRENT_SOURCE_DIR}/qtpy2cpp.py
-          ${CMAKE_CURRENT_SOURCE_DIR}/deploy.py)
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Android")
+    # create Qt6AndroidBindings.jar
+    if (NOT DEFINED ANDROID_SDK_ROOT)
+        message(FATAL_ERROR "Please provide the location of the Android SDK directory via "
+                            "your toolchain file")
+    endif()
+    if (NOT DEFINED ANDROID_PLATFORM)
+        message(FATAL_ERROR "Please provide the location of the Android Platform API level via "
+                            "your toolchain file eg: android-31")
+    endif()
+    include(cmake/PySideAndroid.cmake)
+    create_and_install_qt_javabindings()
+else()
+    set(files ${CMAKE_CURRENT_SOURCE_DIR}/pyside_tool.py
+            ${CMAKE_CURRENT_SOURCE_DIR}/metaobjectdump.py
+            ${CMAKE_CURRENT_SOURCE_DIR}/project.py
+            ${CMAKE_CURRENT_SOURCE_DIR}/qml.py
+            ${CMAKE_CURRENT_SOURCE_DIR}/qtpy2cpp.py
+            ${CMAKE_CURRENT_SOURCE_DIR}/deploy.py
+            ${CMAKE_CURRENT_SOURCE_DIR}/android_deploy.py
+            ${CMAKE_CURRENT_SOURCE_DIR}/requirements-android.txt)
 
-set(directories ${CMAKE_CURRENT_SOURCE_DIR}/deploy
-                ${CMAKE_CURRENT_SOURCE_DIR}/project)
+    set(directories ${CMAKE_CURRENT_SOURCE_DIR}/deploy_lib
+                    ${CMAKE_CURRENT_SOURCE_DIR}/project)
 
-if(NOT NO_QT_TOOLS STREQUAL "yes")
-    set(TOOLS_PATH "${QT6_INSTALL_PREFIX}/${QT6_HOST_INFO_BINDIR}")
-    set(LIBEXEC_PATH "${QT6_INSTALL_PREFIX}/${QT6_HOST_INFO_LIBEXECDIR}")
+    if(NOT NO_QT_TOOLS STREQUAL "yes")
+        set(TOOLS_PATH "${QT6_INSTALL_PREFIX}/${QT6_HOST_INFO_BINDIR}")
+        set(LIBEXEC_PATH "${QT6_INSTALL_PREFIX}/${QT6_HOST_INFO_LIBEXECDIR}")
 
-    list(APPEND files "${LIBEXEC_PATH}/uic${CMAKE_EXECUTABLE_SUFFIX}"
-                      "${LIBEXEC_PATH}/rcc${CMAKE_EXECUTABLE_SUFFIX}"
-                      "${LIBEXEC_PATH}/qmltyperegistrar${CMAKE_EXECUTABLE_SUFFIX}"
-                      "${LIBEXEC_PATH}/qmlimportscanner${CMAKE_EXECUTABLE_SUFFIX}"
-                      "${TOOLS_PATH}/lrelease${CMAKE_EXECUTABLE_SUFFIX}"
-                      "${TOOLS_PATH}/lupdate${CMAKE_EXECUTABLE_SUFFIX}"
-                      "${TOOLS_PATH}/qmllint${CMAKE_EXECUTABLE_SUFFIX}"
-                      "${TOOLS_PATH}/qmlformat${CMAKE_EXECUTABLE_SUFFIX}"
-                      "${TOOLS_PATH}/qmlls${CMAKE_EXECUTABLE_SUFFIX}")
+        list(APPEND files "${LIBEXEC_PATH}/uic${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${LIBEXEC_PATH}/rcc${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${LIBEXEC_PATH}/qmltyperegistrar${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${LIBEXEC_PATH}/qmlimportscanner${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${LIBEXEC_PATH}/qmlcachegen${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${TOOLS_PATH}/lrelease${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${TOOLS_PATH}/lupdate${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${TOOLS_PATH}/qmllint${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${TOOLS_PATH}/qmlformat${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${TOOLS_PATH}/qmlls${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${TOOLS_PATH}/qsb${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${TOOLS_PATH}/balsam${CMAKE_EXECUTABLE_SUFFIX}"
+                        "${TOOLS_PATH}/balsamui${CMAKE_EXECUTABLE_SUFFIX}")
 
-    if (APPLE)
-        list(APPEND directories "${TOOLS_PATH}/Assistant.app"
-                                "${TOOLS_PATH}/Designer.app"
-                                "${TOOLS_PATH}/Linguist.app")
-    else()
-        list(APPEND files "${TOOLS_PATH}/assistant${CMAKE_EXECUTABLE_SUFFIX}"
-                          "${TOOLS_PATH}/designer${CMAKE_EXECUTABLE_SUFFIX}"
-                          "${TOOLS_PATH}/linguist${CMAKE_EXECUTABLE_SUFFIX}")
+        if (APPLE)
+            list(APPEND directories "${TOOLS_PATH}/Assistant.app"
+                                    "${TOOLS_PATH}/Designer.app"
+                                    "${TOOLS_PATH}/Linguist.app")
+        else()
+            list(APPEND files "${TOOLS_PATH}/assistant${CMAKE_EXECUTABLE_SUFFIX}"
+                            "${TOOLS_PATH}/designer${CMAKE_EXECUTABLE_SUFFIX}"
+                            "${TOOLS_PATH}/linguist${CMAKE_EXECUTABLE_SUFFIX}")
+        endif()
     endif()
-endif()
 
-list(APPEND directories ${CMAKE_CURRENT_SOURCE_DIR}/qtpy2cpp_lib)
+    list(APPEND directories ${CMAKE_CURRENT_SOURCE_DIR}/qtpy2cpp_lib)
 
-# pyside6-rcc, pyside6-uic, pyside6-designer, shiboken and pyside6-lupdate entrypoints
+    # pyside6-rcc, pyside6-uic, pyside6-designer, shiboken and pyside6-lupdate entrypoints
+    foreach(file ${files})
+        if(EXISTS ${file})
+            install(FILES "${file}"
+                    DESTINATION bin
+                    PERMISSIONS
+                    OWNER_EXECUTE OWNER_WRITE OWNER_READ
+                    GROUP_EXECUTE GROUP_READ
+                    WORLD_EXECUTE WORLD_READ)
+        else()
+            message(WARNING "${file} does not exist. Hence, pyside6-${file} will not work")
+        endif()
+    endforeach()
 
-foreach(file ${files})
-    if(EXISTS ${file})
-        install(FILES "${file}"
+    foreach(directory ${directories})
+        install(DIRECTORY "${directory}"
                 DESTINATION bin
-                PERMISSIONS
+                FILE_PERMISSIONS
                 OWNER_EXECUTE OWNER_WRITE OWNER_READ
                 GROUP_EXECUTE GROUP_READ
                 WORLD_EXECUTE WORLD_READ)
-    else()
-        message(WARNING "${file} does not exist. Hence, pyside6-${file} will not work")
-    endif()
-endforeach()
-
-foreach(directory ${directories})
-    install(DIRECTORY "${directory}"
-            DESTINATION bin
-            FILE_PERMISSIONS
-            OWNER_EXECUTE OWNER_WRITE OWNER_READ
-            GROUP_EXECUTE GROUP_READ
-            WORLD_EXECUTE WORLD_READ)
-endforeach()
+    endforeach()
+endif()
diff --git a/sources/pyside-tools/__init__.py b/sources/pyside-tools/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/sources/pyside-tools/__init__.py
diff --git a/sources/pyside-tools/android_deploy.py b/sources/pyside-tools/android_deploy.py
new file mode 100644
index 000000000..75269d622
--- /dev/null
+++ b/sources/pyside-tools/android_deploy.py
@@ -0,0 +1,212 @@
+# 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 argparse
+import logging
+import shutil
+import traceback
+from pathlib import Path
+from textwrap import dedent
+
+from deploy_lib import (create_config_file, cleanup, config_option_exists, PythonExecutable,
+                        MAJOR_VERSION, HELP_EXTRA_IGNORE_DIRS, HELP_EXTRA_MODULES)
+from deploy_lib.android import AndroidData, AndroidConfig
+from deploy_lib.android.buildozer import Buildozer
+
+
+""" pyside6-android-deploy deployment tool
+
+    Deployment tool that uses buildozer (https://buildozer.readthedocs.io/en/latest/) and
+    python-for-android (https://python-for-android.readthedocs.io/en/latest/) to deploy PySide6
+    applications to Android
+
+    How does it work?
+
+    Command: pyside6-android-deploy --wheel-pyside=<pyside_wheel_path>
+                                    --wheel-shiboken=<shiboken_wheel_path>
+                                    --ndk-path=<optional_ndk_path>
+                                    --sdk-path=<optional_sdk_path>
+             pyside6-android-deploy android -c /path/to/pysidedeploy.spec
+
+
+    Note: If --ndk-path and --sdk-path are not specified, the cache of the tool
+    `.pyside6_android_deploy` is checked in the user's HOME directory. If it is not found, the user
+    will have to manually download them.
+
+    Prerequisities: Python main entrypoint file should be named "main.py"
+
+    Platforms Supported: aarch64, armv7a, i686, x86_64
+
+    Config file:
+        On the first run of the tool, it creates a config file called pysidedeploy.spec which
+        controls the various characteristic of the deployment. Users can simply change the value
+        in this config file to achieve different properties ie. change the application name,
+        deployment platform etc.
+
+        Note: This file is used by both pyside6-deploy and pyside6-android-deploy
+"""
+
+
+def main(name: str = None, pyside_wheel: Path = None, shiboken_wheel: Path = None,
+         ndk_path: Path = None, sdk_path: Path = None, config_file: Path = None, init: bool = False,
+         loglevel=logging.WARNING, dry_run: bool = False, keep_deployment_files: bool = False,
+         force: bool = False, extra_ignore_dirs: str = None, extra_modules_grouped: str = None):
+
+    logging.basicConfig(level=loglevel)
+
+    if extra_ignore_dirs:
+        extra_ignore_dirs = extra_ignore_dirs.split(",")
+
+    extra_modules = []
+    if extra_modules_grouped:
+        tmp_extra_modules = extra_modules_grouped.split(",")
+        for extra_module in tmp_extra_modules:
+            if extra_module.startswith("Qt"):
+                extra_modules.append(extra_module[2:])
+            else:
+                extra_modules.append(extra_module)
+
+    main_file = Path.cwd() / "main.py"
+    if not main_file.exists():
+        raise RuntimeError(("[DEPLOY] For Android deployment to work, the main"
+                            " entrypoint Python file should be named 'main.py'"
+                            " and it should be run from the application"
+                            " directory"))
+
+    android_data = AndroidData(wheel_pyside=pyside_wheel, wheel_shiboken=shiboken_wheel,
+                               ndk_path=ndk_path, sdk_path=sdk_path)
+
+    python = PythonExecutable(dry_run=dry_run, init=init, force=force)
+
+    config_file_exists = config_file and Path(config_file).exists()
+
+    if config_file_exists:
+        logging.info(f"[DEPLOY] Using existing config file {config_file}")
+    else:
+        config_file = create_config_file(dry_run=dry_run, config_file=config_file,
+                                         main_file=main_file)
+
+    config = AndroidConfig(config_file=config_file, source_file=main_file,
+                           python_exe=python.exe, dry_run=dry_run, android_data=android_data,
+                           existing_config_file=config_file_exists,
+                           extra_ignore_dirs=extra_ignore_dirs)
+
+    if not config.wheel_pyside and not config.wheel_shiboken:
+        raise RuntimeError(f"[DEPLOY] No PySide{MAJOR_VERSION} and Shiboken{MAJOR_VERSION} wheels"
+                           "found")
+
+    cleanup(config=config, is_android=True)
+
+    python.install_dependencies(config=config, packages="android_packages", is_android=True)
+
+    # set application name
+    if name:
+        config.title = name
+
+    try:
+        config.modules += list(set(extra_modules).difference(set(config.modules)))
+
+        # this cannot be done when config file is initialized because cleanup() removes it
+        # so this can only be done after the cleanup()
+        config.find_and_set_jars_dir()
+        config.verify_and_set_recipe_dir()
+
+        # TODO: include qml files from pysidedeploy.spec rather than from extensions
+        # buildozer currently includes all the files with .qml extension
+
+        # init buildozer
+        Buildozer.dry_run = dry_run
+        logging.info("[DEPLOY] Creating buildozer.spec file")
+        Buildozer.initialize(pysidedeploy_config=config)
+
+        # writing config file
+        if not dry_run:
+            config.update_config()
+
+        if init:
+            # config file created above. Exiting.
+            logging.info(f"[DEPLOY]: Config file  {config.config_file} created")
+            return
+
+        # run buildozer
+        logging.info("[DEPLOY] Running buildozer deployment")
+        Buildozer.create_executable(config.mode)
+
+        # move buildozer build files to {generated_files_path}
+        if not dry_run:
+            buildozer_build_dir = config.project_dir / ".buildozer"
+            if not buildozer_build_dir.exists():
+                logging.info(f"[DEPLOY] Unable to copy {buildozer_build_dir} to "
+                             f"{config.generated_files_path}. {buildozer_build_dir} does not exist")
+            logging.info(f"[DEPLOY] copy {buildozer_build_dir} to {config.generated_files_path}")
+            shutil.move(buildozer_build_dir, config.generated_files_path)
+
+        logging.info(f"[DEPLOY] apk created in {config.exe_dir}")
+    except Exception:
+        print(f"Exception occurred: {traceback.format_exc()}")
+    finally:
+        if config.generated_files_path and config and not keep_deployment_files:
+            cleanup(config=config, is_android=True)
+
+    logging.info("[DEPLOY] End")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description=dedent(f"""
+                           This tool deploys PySide{MAJOR_VERSION} to Android platforms.
+
+                           Note: The main python entrypoint should be named main.py
+                           """),
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+
+    parser.add_argument("-c", "--config-file", type=lambda p: Path(p).absolute(),
+                        default=(Path.cwd() / "pysidedeploy.spec"),
+                        help="Path to the .spec config file")
+
+    parser.add_argument(
+        "--init", action="store_true",
+        help="Create pysidedeploy.spec file, if it doesn't already exists")
+
+    parser.add_argument(
+        "-v", "--verbose", help="run in verbose mode", action="store_const",
+        dest="loglevel", const=logging.INFO)
+
+    parser.add_argument("--dry-run", action="store_true", help="show the commands to be run")
+
+    parser.add_argument("--keep-deployment-files", action="store_true",
+                        help="keep the generated deployment files generated")
+
+    parser.add_argument("-f", "--force", action="store_true", help="force all input prompts")
+
+    parser.add_argument("--name", type=str, help="Application name")
+
+    parser.add_argument("--wheel-pyside", type=lambda p: Path(p).resolve(),
+                        help=f"Path to PySide{MAJOR_VERSION} Android Wheel",
+                        required=not config_option_exists())
+
+    parser.add_argument("--wheel-shiboken", type=lambda p: Path(p).resolve(),
+                        help=f"Path to shiboken{MAJOR_VERSION} Android Wheel",
+                        required=not config_option_exists())
+
+    parser.add_argument("--ndk-path", type=lambda p: Path(p).resolve(),
+                        help=("Path to Android NDK. If omitted, the tool's cache at "
+                              ".pyside6_android_deploy is checked to find the NDK")
+                        )
+
+    parser.add_argument("--sdk-path", type=lambda p: Path(p).resolve(),
+                        help=("Path to Android SDK. If omitted, the tool's cache at "
+                              ".pyside6_android_deploy is checked to find the SDK. Otherwise "
+                              "the default from buildozer is used.")
+                        )
+
+    parser.add_argument("--extra-ignore-dirs", type=str, help=HELP_EXTRA_IGNORE_DIRS)
+
+    parser.add_argument("--extra-modules", type=str, help=HELP_EXTRA_MODULES)
+
+    args = parser.parse_args()
+
+    main(args.name, args.wheel_pyside, args.wheel_shiboken, args.ndk_path, args.sdk_path,
+         args.config_file, args.init, args.loglevel, args.dry_run, args.keep_deployment_files,
+         args.force, args.extra_ignore_dirs, args.extra_modules)
diff --git a/sources/pyside-tools/android_deploy.pyproject b/sources/pyside-tools/android_deploy.pyproject
new file mode 100644
index 000000000..bc6347243
--- /dev/null
+++ b/sources/pyside-tools/android_deploy.pyproject
@@ -0,0 +1,9 @@
+{
+    "files": ["deploy.py", "deploy_lib/__init__.py", "deploy_lib/commands.py", "deploy_lib/config.py",
+              "deploy_lib/default.spec", "deploy_lib/python_helper.py", "deploy_lib/deploy_util.py",
+              "deploy_lib/android/recipes/PySide6/__init__.tmpl.py",
+              "deploy_lib/android/recipes/shiboken6/__init__.tmpl.py",
+              "deploy_lib/android/__init__.py", "deploy_lib/android/android_helper.py",
+              "deploy_lib/android/buildozer.py", "deploy_lib/dependency_util.py"
+              ]
+}
diff --git a/sources/pyside-tools/cmake/PySideAndroid.cmake b/sources/pyside-tools/cmake/PySideAndroid.cmake
new file mode 100644
index 000000000..4b6260cce
--- /dev/null
+++ b/sources/pyside-tools/cmake/PySideAndroid.cmake
@@ -0,0 +1,52 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+set(QT_MAJOR_VERSION 6)
+
+# Locate Java
+include(UseJava)
+# Find JDK 8.0
+find_package(Java 1.8 COMPONENTS Development REQUIRED)
+# Find QtJavaHelpers.java
+include("${QT6_INSTALL_PREFIX}/${QT6_INSTALL_LIBS}/cmake/Qt6/QtJavaHelpers.cmake")
+
+macro(create_and_install_qt_javabindings)
+
+    # create Qt6AndroidBindings.jar from the following {java_sources}
+    set(android_main_srcs "${QT6_INSTALL_PREFIX}/src/android/java/src/org/qtproject/qt/android/bindings")
+    set(java_sources
+        ${android_main_srcs}/QtActivity.java
+        ${android_main_srcs}/QtApplication.java
+        ${android_main_srcs}/QtService.java
+    )
+    # set android.jar from the sdk, for compiling the java files into .jar
+    set(sdk_jar_location "${ANDROID_SDK_ROOT}/platforms/${ANDROID_PLATFORM}/android.jar")
+    if (NOT EXISTS "${sdk_jar_location}")
+        message(FATAL_ERROR "Could not locate Android SDK jar for api '${api}'")
+    endif()
+
+    # this variable is accessed by qt_internal_add_jar
+    set(QT_ANDROID_JAR ${sdk_jar_location})
+
+    set(qt_jar_location "${QT6_INSTALL_PREFIX}/jar/Qt6Android.jar")
+    if (NOT EXISTS "${qt_jar_location}")
+        message(FATAL_ERROR "${qt_jar_location} does not exist. Qt6 installation maybe corrupted.")
+    endif()
+
+    # to be done
+    list(APPEND included_jars ${sdk_jar_location} ${qt_jar_location})
+
+    qt_internal_add_jar(Qt${QT_MAJOR_VERSION}AndroidBindings
+        INCLUDE_JARS ${included_jars}
+        SOURCES ${java_sources}
+    )
+
+    install_jar(Qt${QT_MAJOR_VERSION}AndroidBindings
+        DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/jar"
+        COMPONENT Devel
+    )
+
+    # install other relevant Android jars from the Qt installation.
+    # All the jars would be later packaged together with the Android wheels
+    install(DIRECTORY ${QT6_INSTALL_PREFIX}/jar/ DESTINATION lib/jar)
+endmacro()
diff --git a/sources/pyside-tools/cmake/PySideToolsHelpers.cmake b/sources/pyside-tools/cmake/PySideToolsHelpers.cmake
index c153e46f0..9fb2ec3d0 100644
--- a/sources/pyside-tools/cmake/PySideToolsHelpers.cmake
+++ b/sources/pyside-tools/cmake/PySideToolsHelpers.cmake
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 function(pyside_tools_internal_detect_if_cross_building)
     if(CMAKE_CROSSCOMPILING OR QFP_SHIBOKEN_HOST_PATH)
         set(is_cross_build TRUE)
diff --git a/sources/pyside-tools/cmake/PySideToolsSetup.cmake b/sources/pyside-tools/cmake/PySideToolsSetup.cmake
index cdccef2fd..93b39460d 100644
--- a/sources/pyside-tools/cmake/PySideToolsSetup.cmake
+++ b/sources/pyside-tools/cmake/PySideToolsSetup.cmake
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
 
 include(PySideToolsHelpers)
diff --git a/sources/pyside-tools/deploy.py b/sources/pyside-tools/deploy.py
index 2dde34ad3..aa03d13d0 100644
--- a/sources/pyside-tools/deploy.py
+++ b/sources/pyside-tools/deploy.py
@@ -1,67 +1,159 @@
 # 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
 
-"""pyside6-deploy deployment tool
-
-   How does it work?
-
-   Running "pyside6-deploy path/to/main_file" will
-    1. Create a pysidedeploy.spec config file to control the overall deployment process
-    2. Prompt the user to create a virtual environment (if not in one already)
-       If yes, virtual environment is created in the current folder
-       If no, uses the system wide python
-    3. Install all dependencies and figure out Qt nuitka optimizations
-    2. Use the spec file by android deploy tool or nuitka (desktop), to
-       create the executable
-
-   Desktop deployment: Wrapper around Nuitka with support for Windows,
-   Linux, Mac
-     1. for non-QML cases, only required modules are included
-     2. for QML cases, all modules are included because of all QML
-        plugins getting included with nuitka
-
-   For other ways of using the tool:
-     1. pyside6-deploy (incase main file is called main.py)
-     2. pyside6-deploy -c /path/to/config_file
+""" pyside6-deploy deployment tool
+
+    Deployment tool that uses Nuitka to deploy PySide6 applications to various desktop (Windows,
+    Linux, macOS) platforms.
+
+    How does it work?
+
+    Command: pyside6-deploy path/to/main_file
+             pyside6-deploy (incase main file is called main.py)
+             pyside6-deploy -c /path/to/config_file
+
+    Platforms supported: Linux, Windows, macOS
+    Module binary inclusion:
+        1. for non-QML cases, only required modules are included
+        2. for QML cases, all modules are included because of all QML plugins getting included
+            with nuitka
+
+    Config file:
+        On the first run of the tool, it creates a config file called pysidedeploy.spec which
+        controls the various characteristic of the deployment. Users can simply change the value
+        in this config file to achieve different properties ie. change the application name,
+        deployment platform etc.
+
+        Note: This file is used by both pyside6-deploy and pyside6-android-deploy
+
 """
 
 import argparse
 import logging
-import sys
-from pathlib import Path
-import shutil
 import traceback
+from pathlib import Path
+from textwrap import dedent
+
+from deploy_lib import (MAJOR_VERSION, DesktopConfig, cleanup, config_option_exists,
+                        finalize, create_config_file, PythonExecutable, Nuitka,
+                        HELP_EXTRA_MODULES, HELP_EXTRA_IGNORE_DIRS)
 
-from deploy import Config, PythonExecutable
 
-MAJOR_VERSION = 6
-EXE_FORMAT = ".exe" if sys.platform == "win32" else ".bin"
+TOOL_DESCRIPTION = dedent(f"""
+                          This tool deploys PySide{MAJOR_VERSION} to desktop (Windows, Linux,
+                          macOS) platforms. The following types of executables are produced as per
+                          the platform:
 
+                          Windows = .exe
+                          macOS = .app
+                          Linux = .bin
+                          """)
 
-def config_option_exists():
-    return True if any(item in sys.argv for item in ["--config-file", "-c"]) else False
 
+def main(main_file: Path = None, name: str = None, config_file: Path = None, init: bool = False,
+         loglevel=logging.WARNING, dry_run: bool = False, keep_deployment_files: bool = False,
+         force: bool = False, extra_ignore_dirs: str = None, extra_modules_grouped: str = None):
 
-def main_py_exists():
-    return (Path.cwd() / "main.py").exists()
+    logging.basicConfig(level=loglevel)
+    if config_file and not config_file.exists() and not main_file.exists():
+        raise RuntimeError(dedent("""
+            Directory does not contain main.py file.
+            Please specify the main python entrypoint file or the config file.
+            Run "pyside6-deploy desktop --help" to see info about cli options.
 
+            pyside6-deploy exiting..."""))
 
-def clean(purge_path: Path):
-    """remove the generated deployment files"""
-    if purge_path.exists():
-        shutil.rmtree(purge_path)
-        logging.info("[DEPLOY]: deployment directory purged")
+    # Nuitka command to run
+    command_str = None
+    config = None
+    logging.info("[DEPLOY] Start")
+
+    if extra_ignore_dirs:
+        extra_ignore_dirs = extra_ignore_dirs.split(",")
+
+    extra_modules = []
+    if extra_modules_grouped:
+        tmp_extra_modules = extra_modules_grouped.split(",")
+        for extra_module in tmp_extra_modules:
+            if extra_module.startswith("Qt"):
+                extra_modules.append(extra_module[2:])
+            else:
+                extra_modules.append(extra_module)
+
+    python = PythonExecutable(dry_run=dry_run, init=init, force=force)
+    config_file_exists = config_file and Path(config_file).exists()
+
+    if config_file_exists:
+        logging.info(f"[DEPLOY] Using existing config file {config_file}")
     else:
-        print(f"{purge_path} does not exist")
+        config_file = create_config_file(dry_run=dry_run, config_file=config_file,
+                                         main_file=main_file)
+
+    config = DesktopConfig(config_file=config_file, source_file=main_file, python_exe=python.exe,
+                           dry_run=dry_run, existing_config_file=config_file_exists,
+                           extra_ignore_dirs=extra_ignore_dirs)
+
+    # set application name
+    if name:
+        config.title = name
+
+    cleanup(config=config)
+
+    python.install_dependencies(config=config, packages="packages")
+
+    # required by Nuitka for pyenv Python
+    add_arg = " --static-libpython=no"
+    if python.is_pyenv_python() and add_arg not in config.extra_args:
+        config.extra_args += add_arg
+
+    config.modules += list(set(extra_modules).difference(set(config.modules)))
+
+    # writing config file
+    # in the case of --dry-run, we use default.spec as reference. Do not save the changes
+    # for --dry-run
+    if not dry_run:
+        config.update_config()
+
+    if config.qml_files:
+        logging.info(f"[DEPLOY] Included QML files: {config.qml_files}")
+
+    if init:
+        # config file created above. Exiting.
+        logging.info(f"[DEPLOY]: Config file {config.config_file} created")
+        return
+
+    try:
+        # create executable
+        if not dry_run:
+            logging.info("[DEPLOY] Deploying application")
+
+        nuitka = Nuitka(nuitka=[python.exe, "-m", "nuitka"])
+        command_str = nuitka.create_executable(source_file=config.source_file,
+                                               extra_args=config.extra_args,
+                                               qml_files=config.qml_files,
+                                               qt_plugins=config.qt_plugins,
+                                               excluded_qml_plugins=config.excluded_qml_plugins,
+                                               icon=config.icon,
+                                               dry_run=dry_run,
+                                               permissions=config.permissions)
+    except Exception:
+        print(f"[DEPLOY] Exception occurred: {traceback.format_exc()}")
+    finally:
+        if config.generated_files_path and config:
+            finalize(config=config)
+            if not keep_deployment_files:
+                cleanup(config=config)
+
+    logging.info("[DEPLOY] End")
+    return command_str
 
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description=f"This tool deploys PySide{MAJOR_VERSION} to different platforms",
-        formatter_class=argparse.RawTextHelpFormatter,
-    )
+    parser = argparse.ArgumentParser(description=TOOL_DESCRIPTION)
 
-    parser.add_argument("-c", "--config-file", type=str, help="Path to the .spec config file")
+    parser.add_argument("-c", "--config-file", type=lambda p: Path(p).absolute(),
+                        default=(Path.cwd() / "pysidedeploy.spec"),
+                        help="Path to the .spec config file")
 
     parser.add_argument(
         type=lambda p: Path(p).absolute(),
@@ -73,123 +165,24 @@ if __name__ == "__main__":
         help="Create pysidedeploy.spec file, if it doesn't already exists")
 
     parser.add_argument(
-        "-v", "--verbose", help="run in verbose mode", action="store_const",
+        "-v", "--verbose", help="Run in verbose mode", action="store_const",
         dest="loglevel", const=logging.INFO)
 
-    parser.add_argument("--dry-run", action="store_true", help="show the commands to be run")
+    parser.add_argument("--dry-run", action="store_true", help="Show the commands to be run")
 
     parser.add_argument(
-        "--keep-deployment-files",action="store_true",
-        help="keep the generated deployment files generated",)
+        "--keep-deployment-files", action="store_true",
+        help="Keep the generated deployment files generated")
 
-    parser.add_argument("-f", "--force", action="store_true", help="force all input prompts")
+    parser.add_argument("-f", "--force", action="store_true", help="Force all input prompts")
 
-    args = parser.parse_args()
-    logging.basicConfig(level=args.loglevel)
-    config_file = Path(args.config_file) if args.config_file else None
+    parser.add_argument("--name", type=str, help="Application name")
 
-    if args.main_file:
-        if args.main_file.parent != Path.cwd():
-            config_file = args.main_file.parent / "pysidedeploy.spec"
-        else:
-            config_file = Path.cwd() / "pysidedeploy.spec"
+    parser.add_argument("--extra-ignore-dirs", type=str, help=HELP_EXTRA_IGNORE_DIRS)
 
-    final_exec_path = None
-    config = Config(config_file=config_file)
+    parser.add_argument("--extra-modules", type=str, help=HELP_EXTRA_MODULES)
 
-    # set if available, else fetch from config_file
-    source_file = Path(
-        config.set_or_fetch(config_property_val=args.main_file, config_property_key="input_file")
-    )
-
-    if config.project_dir:
-        source_file = config.project_dir / source_file
-
-    generated_files_path = source_file.parent / "deployment"
-    if generated_files_path.exists():
-        clean(generated_files_path)
-
-    logging.info("[DEPLOY]: Start")
-
-    try:
-        python = None
-        python_path = config.get_value("python", "python_path")
-        if python_path and Path(python_path).exists():
-            python = PythonExecutable(Path(python_path), dry_run=args.dry_run)
-        else:
-            # checking if inside virtual environment
-            if not PythonExecutable.is_venv():
-                if not args.force:
-                    response = input("Not in virtualenv. Do you want to create one? [Y/n]")
-                else:
-                    response = "no"
-
-                if response.lower() in "yes":
-                    # creating new virtual environment
-                    python = PythonExecutable(create_venv=True, dry_run=args.dry_run)
-                    logging.info("[DEPLOY]: virutalenv created")
-
-            # in venv or user entered no
-            if not python:
-                python = PythonExecutable(dry_run=args.dry_run)
-                logging.info(f"[DEPLOY]: using python at {sys.executable}")
-
-        config.set_value("python", "python_path", str(python.exe))
-
-        if not args.init and not args.dry_run:
-            # install packages needed for deployment
-            print("[DEPLOY] Installing dependencies \n")
-            packages = config.get_value("python", "packages").split(",")
-            python.install(packages=packages)
-            # nuitka requires patchelf to make patchelf rpath changes for some Qt files
-            if sys.platform.startswith("linux"):
-                python.install(packages=["patchelf"])
-
-        # identify and set qml files
-        config.find_and_set_qml_files()
-
-        if not config.project_dir:
-            config.find_and_set_project_dir()
-
-        if config.project_dir == Path.cwd():
-            final_exec_path = config.project_dir.relative_to(Path.cwd())
-        else:
-            final_exec_path = config.project_dir
-        final_exec_path = Path(
-            config.set_or_fetch(
-                config_property_val=final_exec_path, config_property_key="exec_directory"
-            )
-        ).absolute()
-
-        if not args.dry_run:
-            config.update_config()
-
-        if args.init:
-            # config file created above. Exiting.
-            logging.info(f"[DEPLOY]: Config file  {args.config_file} created")
-            sys.exit(0)
+    args = parser.parse_args()
 
-        # create executable
-        if not args.dry_run:
-            print("[DEPLOY] Deploying application")
-        python.create_executable(
-            source_file=source_file,
-            extra_args=config.get_value("nuitka", "extra_args"),
-            config=config,
-        )
-    except Exception:
-        print(f"Exception occurred: {traceback.format_exc()}")
-    finally:
-        # clean up generated deployment files and copy executable into
-        # final_exec_path
-        if not args.keep_deployment_files and not args.dry_run and not args.init:
-            generated_exec_path = generated_files_path / (source_file.stem + EXE_FORMAT)
-            if generated_exec_path.exists() and final_exec_path:
-                shutil.copy(generated_exec_path, final_exec_path)
-                print(
-                    f"[DEPLOY] Executed file created in "
-                    f"{final_exec_path / (source_file.stem + EXE_FORMAT)}"
-                )
-            clean(generated_files_path)
-
-    logging.info("[DEPLOY]: End")
+    main(args.main_file, args.name, args.config_file, args.init, args.loglevel, args.dry_run,
+         args.keep_deployment_files, args.force, args.extra_ignore_dirs, args.extra_modules)
diff --git a/sources/pyside-tools/deploy.pyproject b/sources/pyside-tools/deploy.pyproject
new file mode 100644
index 000000000..0e6ca8251
--- /dev/null
+++ b/sources/pyside-tools/deploy.pyproject
@@ -0,0 +1,8 @@
+{
+    "files": ["deploy.py", "deploy_lib/__init__.py", "deploy_lib/commands.py", "deploy_lib/config.py",
+              "deploy_lib/default.spec", "deploy_lib/nuitka_helper.py", "deploy_lib/pyside_icon.ico",
+              "deploy_lib/pyside_icon.icns","deploy_lib/pyside_icon.jpg",
+              "deploy_lib/python_helper.py", "deploy_lib/deploy_util.py",
+              "deploy_lib/dependency_util.py"
+              ]
+}
diff --git a/sources/pyside-tools/deploy/__init__.py b/sources/pyside-tools/deploy/__init__.py
deleted file mode 100644
index b94bc665b..000000000
--- a/sources/pyside-tools/deploy/__init__.py
+++ /dev/null
@@ -1,7 +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
-
-from .commands import run_command
-from .nuitka_helper import Nuitka
-from .config import Config
-from .python_helper import PythonExecutable
diff --git a/sources/pyside-tools/deploy/commands.py b/sources/pyside-tools/deploy/commands.py
deleted file mode 100644
index 92745367f..000000000
--- a/sources/pyside-tools/deploy/commands.py
+++ /dev/null
@@ -1,31 +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
-
-import subprocess
-import sys
-import logging
-
-"""
-All utility functions for deployment
-"""
-
-
-def run_command(command, dry_run: bool):
-    command_str = " ".join([str(cmd) for cmd in command])
-    try:
-        if not dry_run:
-            subprocess.check_call(command, shell=(sys.platform == "win32"))
-        else:
-            print(command_str + "\n")
-    except FileNotFoundError as error:
-        logging.exception(f"[DEPLOY]: {error.filename} not found")
-        raise
-    except subprocess.CalledProcessError as error:
-        logging.exception(
-             f"[DEPLOY]: Command {command_str} failed with error {error} and return_code"
-             f"{error.returncode}"
-        )
-        raise
-    except Exception as error:
-        logging.exception(f"[DEPLOY]: Command {command_str} failed with error {error}")
-        raise
diff --git a/sources/pyside-tools/deploy/config.py b/sources/pyside-tools/deploy/config.py
deleted file mode 100644
index 3e1c72abe..000000000
--- a/sources/pyside-tools/deploy/config.py
+++ /dev/null
@@ -1,177 +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
-
-from pathlib import Path
-import configparser
-from configparser import ConfigParser
-import shutil
-import logging
-import os
-
-
-class Config:
-    """
-    Wrapper class around config file, whose options are used to control the executable creation
-    """
-
-    def __init__(self, config_file: Path) -> None:
-        self.config_file = config_file
-        self.parser = ConfigParser(comment_prefixes="/", allow_no_value=True)
-        if not self.config_file.exists():
-            logging.info(f"[DEPLOY]: Creating config file {self.config_file}")
-            shutil.copy(Path(__file__).parent / "default.spec", self.config_file)
-        else:
-            print(f"Using existing config file {config_file}")
-        self.parser.read(self.config_file)
-
-        self.project_dir = None
-        if self.get_value("app", "project_dir"):
-            self.project_dir = Path(self.get_value("app", "project_dir")).absolute()
-
-        self.qml_files = []
-        config_qml_files = self.get_value("qt", "qml_files")
-        if config_qml_files and self.project_dir:
-            self.qml_files = [Path(self.project_dir) / file for file in config_qml_files.split(",")]
-
-    def update_config(self):
-        logging.info("[DEPLOY] Creating {config_file}")
-        with open(self.config_file, "w+") as config_file:
-            self.parser.write(config_file, space_around_delimiters=True)
-
-    def set_value(self, section: str, key: str, new_value: str):
-        try:
-            current_value = self.get_value(section, key)
-            if current_value != new_value:
-                self.parser.set(section, key, new_value)
-        except configparser.NoOptionError:
-            logging.warning(f"[DEPLOY]: key {key} does not exist")
-        except configparser.NoSectionError:
-            logging.warning(f"[DEPLOY]: section {section} does not exist")
-
-    def get_value(self, section: str, key: str):
-        try:
-            return self.parser.get(section, key)
-        except configparser.NoOptionError:
-            logging.warning(f"[DEPLOY]: key {key} does not exist")
-        except configparser.NoSectionError:
-            logging.warning(f"[DEPLOY]: section {section} does not exist")
-
-    def set_or_fetch(self, config_property_val, config_property_key, config_property_group="app"):
-        """
-        Write to config_file if 'config_property_key' is known without config_file
-        Fetch and return from config_file if 'config_property_key' is unknown, but
-        config_file exists
-        Otherwise, raise an exception
-        """
-        if config_property_val:
-            self.set_value(config_property_group, config_property_key, str(config_property_val))
-            return config_property_val
-        elif self.get_value(config_property_group, config_property_key):
-            return self.get_value(config_property_group, config_property_key)
-        else:
-            logging.exception(
-                f"[DEPLOY]: No {config_property_key} specified in config file or as cli option"
-            )
-            raise
-
-    @property
-    def qml_files(self):
-        return self._qml_files
-
-    @qml_files.setter
-    def qml_files(self, qml_files):
-        self._qml_files = qml_files
-
-    @property
-    def project_dir(self):
-        return self._project_dir
-
-    @project_dir.setter
-    def project_dir(self, project_dir):
-        self._project_dir = project_dir
-
-    def find_and_set_qml_files(self):
-        """Fetches all the qml_files in the folder and sets them if the
-        field qml_files is empty in the config_dir"""
-
-        if self.project_dir:
-            qml_files_str = self.get_value("qt", "qml_files")
-            self.qml_files = []
-            for file in qml_files_str.split(","):
-                if file:
-                    self.qml_files.append(Path(self.project_dir) / file)
-        else:
-            qml_files_temp = None
-            source_file = (
-                Path(self.get_value("app", "input_file"))
-                if self.get_value("app", "input_file")
-                else None
-            )
-            python_exe = (
-                Path(self.get_value("python", "python_path"))
-                if self.get_value("python", "python_path")
-                else None
-            )
-            if source_file and python_exe:
-                if not self.qml_files:
-                    qml_files_temp = list(source_file.parent.glob("**/*.qml"))
-
-                # add all QML files, excluding the ones shipped with installed PySide6
-                # The QML files shipped with PySide6 gets added if venv is used,
-                # because of recursive glob
-                if python_exe.parent.parent == source_file.parent:
-                    # python venv path is inside the main source dir
-                    qml_files_temp = list(
-                        set(qml_files_temp) - set(python_exe.parent.parent.rglob("*.qml"))
-                    )
-
-                if len(qml_files_temp) > 500:
-                    if "site-packages" in str(qml_files_temp[-1]):
-                        logging.warning(
-                            "You seem to include a lot of QML files from a \
-                                            local virtual env. Are they intended?"
-                        )
-                    else:
-                        logging.warning(
-                            "You seem to include a lot of QML files. \
-                                        Are they intended?"
-                        )
-
-                if qml_files_temp:
-                    extra_qml_files = [Path(file) for file in qml_files_temp]
-                    self.qml_files.extend(extra_qml_files)
-                    self.set_value(
-                        "qt", "qml_files", ",".join([str(file) for file in self.qml_files])
-                    )
-                    logging.info("[DEPLOY] QML files identified and set in config_file")
-
-    def find_and_set_project_dir(self):
-        source_file = (
-            Path(self.get_value("app", "input_file"))
-            if self.get_value("app", "input_file")
-            else None
-        )
-
-        if self.qml_files and source_file:
-            paths = self.qml_files.copy()
-            paths.append(source_file.absolute())
-            self.project_dir = Path(os.path.commonpath(paths=paths))
-
-            # update all qml paths
-            logging.info("[DEPLOY] Update QML files paths to relative paths")
-            qml_relative_paths = ",".join(
-                [str(qml_file.relative_to(self.project_dir)) for qml_file in self.qml_files]
-            )
-            self.set_value("qt", "qml_files", qml_relative_paths)
-        else:
-            self.project_dir = source_file.parent
-
-        # update input_file path
-        logging.info("[DEPLOY] Update input_file path")
-        self.set_value("app", "input_file", str(source_file.relative_to(self.project_dir)))
-
-        logging.info("[DEPLOY] Update project_dir path")
-        if self.project_dir != Path.cwd():
-            self.set_value("app", "project_dir", str(self.project_dir))
-        else:
-            self.set_value("app", "project_dir", str(self.project_dir.relative_to(Path.cwd())))
diff --git a/sources/pyside-tools/deploy/default.spec b/sources/pyside-tools/deploy/default.spec
deleted file mode 100644
index 181efe105..000000000
--- a/sources/pyside-tools/deploy/default.spec
+++ /dev/null
@@ -1,35 +0,0 @@
-[app]
-
-# Title of your application
-title = My Application
-
-# Project Directory
-project_dir =
-
-# Source file path
-input_file =
-
-# Directory where exec is stored
-exec_directory =
-
-[python]
-
-# Python path
-python_path =
-
-# python packages to install
-# ordered-set: increase compile time performance of nuitka packaging
-# zstandard: provides final executable size optimization
-packages = nuitka,ordered_set,zstandard
-
-[qt]
-
-# Comma separated path to QML files required
-# normally all the QML files are added automatically
-qml_files =
-
-[nuitka]
-
-# (str) specify any extra nuitka arguments
-# eg: extra_args = --show-modules --follow-stdlib
-extra_args = --quiet
diff --git a/sources/pyside-tools/deploy/nuitka_helper.py b/sources/pyside-tools/deploy/nuitka_helper.py
deleted file mode 100644
index f7114db79..000000000
--- a/sources/pyside-tools/deploy/nuitka_helper.py
+++ /dev/null
@@ -1,51 +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
-
-import os
-import sys
-from pathlib import Path
-from typing import List
-
-from . import run_command
-
-
-class Nuitka:
-    """
-    Wrapper class around the nuitka executable, enabling its usage through python code
-    """
-
-    def __init__(self, nuitka):
-        self.nuitka = nuitka
-
-    def create_executable(
-        self, source_file: Path, extra_args: str, qml_files: List[Path], dry_run: bool
-    ):
-        extra_args = extra_args.split()
-        qml_args = []
-        if qml_files:
-            # this includes "all" the plugins
-            # FIXME: adding the "qml" plugin is equivalent to "all" because of dependencies
-            # Ideally it should only add the specific qml plugins. eg: quick window, quick controls
-            qml_args.append("--include-qt-plugins=all")
-            qml_args.extend(
-                [f"--include-data-files={qml_file}=./{qml_file.name}" for qml_file in qml_files]
-            )
-
-        output_dir = source_file.parent / "deployment"
-        if not dry_run:
-            output_dir.mkdir(parents=True, exist_ok=True)
-            print("[DEPLOY] Running Nuitka")
-        command = self.nuitka + [
-            os.fspath(source_file),
-            "--follow-imports",
-            "--onefile",
-            "--enable-plugin=pyside6",
-            f"--output-dir={output_dir}",
-        ]
-        command.extend(extra_args + qml_args)
-
-        if sys.platform == "linux":
-            linux_icon = str(Path(__file__).parent / "pyside_icon.jpg")
-            command.append(f"--linux-onefile-icon={linux_icon}")
-
-        run_command(command=command, dry_run=dry_run)
diff --git a/sources/pyside-tools/deploy/python_helper.py b/sources/pyside-tools/deploy/python_helper.py
deleted file mode 100644
index ea5859cea..000000000
--- a/sources/pyside-tools/deploy/python_helper.py
+++ /dev/null
@@ -1,82 +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
-
-import sys
-import os
-import logging
-from importlib import util
-from pathlib import Path
-
-from . import Nuitka, run_command, Config
-
-
-class PythonExecutable:
-    """
-    Wrapper class around Python executable
-    """
-
-    def __init__(self, python_path=None, create_venv=False, dry_run=False):
-        self.exe = python_path if python_path else Path(sys.executable)
-        self.dry_run = dry_run
-        if create_venv:
-            self.__create_venv()
-        self.nuitka = Nuitka(nuitka=[os.fspath(self.exe), "-m", "nuitka"])
-
-    @property
-    def exe(self):
-        return Path(self._exe)
-
-    @exe.setter
-    def exe(self, exe):
-        self._exe = exe
-
-    @staticmethod
-    def is_venv():
-        venv = os.environ.get("VIRTUAL_ENV")
-        return True if venv else False
-
-    def __create_venv(self):
-        self.install("virtualenv")
-        if not self.is_venv():
-            run_command(
-                command=[self.exe, "-m", "venv", Path.cwd() / "deployment" / "venv"],
-                dry_run=self.dry_run,
-            )
-            venv_path = Path(os.environ["VIRTUAL_ENV"])
-            if sys.platform == "win32":
-                self.exe = venv_path / "Scripts" / "python.exe"
-            elif sys.platform in ["linux", "darwin"]:
-                self.exe = venv_path / "bin" / "python"
-        else:
-            logging.info("[DEPLOY]: You are already in virtual environment!")
-
-    def install(self, packages: list = None):
-        if packages:
-            for package in packages:
-                if not self.is_installed(package=package):
-                    logging.info(f"[DEPLOY]: Installing package: {package}")
-                    run_command(
-                        command=[self.exe, "-m", "pip", "install", package],
-                        dry_run=self.dry_run,
-                    )
-                else:
-                    logging.info(f"[DEPLOY]: Upgrading package: {package}")
-                    run_command(
-                        command=[self.exe, "-m", "pip", "install", "--upgrade", package],
-                        dry_run=self.dry_run,
-                    )
-
-    def is_installed(self, package):
-        return bool(util.find_spec(package))
-
-    def create_executable(self, source_file: Path, extra_args: str, config: Config):
-        if config.qml_files:
-            logging.info(f"[DEPLOY]: Included QML files: {config.qml_files}")
-
-        self.nuitka.create_executable(
-            source_file=source_file,
-            extra_args=extra_args,
-            qml_files=config.qml_files,
-            dry_run=self.dry_run,
-        )
-
diff --git a/sources/pyside-tools/deploy_lib/__init__.py b/sources/pyside-tools/deploy_lib/__init__.py
new file mode 100644
index 000000000..a40d0838b
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/__init__.py
@@ -0,0 +1,59 @@
+# 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 pathlib import Path
+from textwrap import dedent
+
+MAJOR_VERSION = 6
+
+if sys.platform == "win32":
+    IMAGE_FORMAT = ".ico"
+    EXE_FORMAT = ".exe"
+elif sys.platform == "darwin":
+    IMAGE_FORMAT = ".icns"
+    EXE_FORMAT = ".app"
+else:
+    IMAGE_FORMAT = ".jpg"
+    EXE_FORMAT = ".bin"
+
+DEFAULT_APP_ICON = str((Path(__file__).parent / f"pyside_icon{IMAGE_FORMAT}").resolve())
+IMPORT_WARNING_PYSIDE = (f"[DEPLOY] Found 'import PySide6' in file {0}"
+                         ". Use 'from PySide6 import <module>' or pass the module"
+                         " needed using --extra-modules command line argument")
+HELP_EXTRA_IGNORE_DIRS = dedent("""
+                                Comma-separated directory names inside the project dir. These
+                                directories will be skipped when searching for Python files
+                                relevant to the project.
+
+                                Example usage: --extra-ignore-dirs=doc,translations
+                                """)
+
+HELP_EXTRA_MODULES = dedent("""
+                            Comma-separated list of Qt modules to be added to the application,
+                            in case they are not found automatically.
+
+                            This occurs when you have 'import PySide6' in your code instead
+                            'from PySide6 import <module>'. The module name is specified
+                            by either omitting the prefix of Qt or including it.
+
+                            Example usage 1: --extra-modules=Network,Svg
+                            Example usage 2: --extra-modules=QtNetwork,QtSvg
+                            """)
+
+
+def get_all_pyside_modules():
+    """
+    Returns all the modules installed with PySide6
+    """
+    import PySide6
+    # They all start with `Qt` as the prefix. Removing this prefix and getting the actual
+    # module name
+    return [module[2:] for module in PySide6.__all__]
+
+
+from .commands import run_command, run_qmlimportscanner
+from .dependency_util import find_pyside_modules, find_permission_categories, QtDependencyReader
+from .nuitka_helper import Nuitka
+from .config import BaseConfig, Config, DesktopConfig
+from .python_helper import PythonExecutable
+from .deploy_util import cleanup, finalize, create_config_file, config_option_exists
diff --git a/sources/pyside-tools/deploy_lib/android/__init__.py b/sources/pyside-tools/deploy_lib/android/__init__.py
new file mode 100644
index 000000000..c3027762c
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/android/__init__.py
@@ -0,0 +1,16 @@
+# 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
+
+# maps instruction set to Android platform names
+platform_map = {"aarch64": "arm64-v8a",
+                "armv7a": "armeabi-v7a",
+                "i686": "x86",
+                "x86_64": "x86_64",
+                "arm64-v8a": "arm64-v8a",
+                "armeabi-v7a": "armeabi-v7a",
+                "x86": "x86"}
+
+from .android_helper import (create_recipe, extract_and_copy_jar, get_wheel_android_arch,
+                             AndroidData, get_llvm_readobj, find_lib_dependencies,
+                             find_qtlibs_in_wheel)
+from .android_config import AndroidConfig
diff --git a/sources/pyside-tools/deploy_lib/android/android_config.py b/sources/pyside-tools/deploy_lib/android/android_config.py
new file mode 100644
index 000000000..ad818c2ff
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/android/android_config.py
@@ -0,0 +1,446 @@
+# 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 re
+import tempfile
+import logging
+import zipfile
+import xml.etree.ElementTree as ET
+
+from typing import List
+from pathlib import Path
+from pkginfo import Wheel
+
+from . import (extract_and_copy_jar, get_wheel_android_arch, find_lib_dependencies,
+               get_llvm_readobj, find_qtlibs_in_wheel, platform_map, create_recipe)
+from .. import (Config, find_pyside_modules, get_all_pyside_modules, MAJOR_VERSION)
+
+ANDROID_NDK_VERSION = "26b"
+ANDROID_DEPLOY_CACHE = Path.home() / ".pyside6_android_deploy"
+
+
+class AndroidConfig(Config):
+    """
+    Wrapper class around pysidedeploy.spec file for pyside6-android-deploy
+    """
+    def __init__(self, config_file: Path, source_file: Path, python_exe: Path, dry_run: bool,
+                 android_data, existing_config_file: bool = False,
+                 extra_ignore_dirs: List[str] = None):
+        super().__init__(config_file=config_file, source_file=source_file, python_exe=python_exe,
+                         dry_run=dry_run, existing_config_file=existing_config_file)
+
+        self.extra_ignore_dirs = extra_ignore_dirs
+
+        if android_data.wheel_pyside:
+            self.wheel_pyside = android_data.wheel_pyside
+        else:
+            wheel_pyside_temp = self.get_value("android", "wheel_pyside")
+            if not wheel_pyside_temp:
+                raise RuntimeError("[DEPLOY] Unable to find PySide6 Android wheel")
+            self.wheel_pyside = Path(wheel_pyside_temp).resolve()
+
+        if android_data.wheel_shiboken:
+            self.wheel_shiboken = android_data.wheel_shiboken
+        else:
+            wheel_shiboken_temp = self.get_value("android", "wheel_shiboken")
+            if not wheel_shiboken_temp:
+                raise RuntimeError("[DEPLOY] Unable to find shiboken6 Android wheel")
+            self.wheel_shiboken = Path(wheel_shiboken_temp).resolve()
+
+        self.ndk_path = None
+        if android_data.ndk_path:
+            # from cli
+            self.ndk_path = android_data.ndk_path
+        else:
+            # from config
+            ndk_path_temp = self.get_value("buildozer", "ndk_path")
+            if ndk_path_temp:
+                self.ndk_path = Path(ndk_path_temp)
+            else:
+                ndk_path_temp = (ANDROID_DEPLOY_CACHE / "android-ndk"
+                                 / f"android-ndk-r{ANDROID_NDK_VERSION}")
+                if ndk_path_temp.exists():
+                    self.ndk_path = ndk_path_temp
+
+        if self.ndk_path:
+            print(f"Using Android NDK: {str(self.ndk_path)}")
+        else:
+            raise FileNotFoundError("[DEPLOY] Unable to find Android NDK. Please pass the NDK "
+                                    "path either from the CLI or from pysidedeploy.spec")
+
+        self.sdk_path = None
+        if android_data.sdk_path:
+            self.sdk_path = android_data.sdk_path
+        else:
+            sdk_path_temp = self.get_value("buildozer", "sdk_path")
+            if sdk_path_temp:
+                self.sdk_path = Path(sdk_path_temp)
+            else:
+                sdk_path_temp = ANDROID_DEPLOY_CACHE / "android-sdk"
+                if sdk_path_temp.exists():
+                    self.sdk_path = sdk_path_temp
+                else:
+                    logging.info("[DEPLOY] Use default SDK from buildozer")
+
+        if self.sdk_path:
+            print(f"Using Android SDK: {str(self.sdk_path)}")
+
+        recipe_dir_temp = self.get_value("buildozer", "recipe_dir")
+        self.recipe_dir = Path(recipe_dir_temp) if recipe_dir_temp else None
+
+        self._jars_dir = []
+        jars_dir_temp = self.get_value("buildozer", "jars_dir")
+        if jars_dir_temp and Path(jars_dir_temp).resolve().exists():
+            self.jars_dir = Path(jars_dir_temp).resolve()
+
+        self._arch = None
+        if self.get_value("buildozer", "arch"):
+            self.arch = self.get_value("buildozer", "arch")
+        else:
+            self._find_and_set_arch()
+
+        # maps to correct platform name incase the instruction set was specified
+        self._arch = platform_map[self.arch]
+
+        self._mode = self.get_value("buildozer", "mode")
+
+        self.qt_libs_path: zipfile.Path = find_qtlibs_in_wheel(wheel_pyside=self.wheel_pyside)
+        logging.info(f"[DEPLOY] Qt libs path inside wheel: {str(self.qt_libs_path)}")
+
+        if self.get_value("qt", "modules"):
+            self.modules = self.get_value("qt", "modules").split(",")
+        else:
+            self._find_and_set_pysidemodules()
+            self._find_and_set_qtquick_modules()
+            self.modules += self._find_dependent_qt_modules()
+            # remove duplicates
+            self.modules = list(set(self.modules))
+
+        # gets the xml dependency files from Qt installation path
+        self._dependency_files = []
+        self._find_and_set_dependency_files()
+
+        dependent_plugins = []
+        self._local_libs = []
+        if self.get_value("buildozer", "local_libs"):
+            self._local_libs = self.get_value("buildozer", "local_libs").split(",")
+        else:
+            # the local_libs can also store dependent plugins
+            local_libs, dependent_plugins = self._find_local_libs()
+            self.local_libs = list(set(local_libs))
+
+        self._qt_plugins = []
+        if self.get_value("android", "plugins"):
+            self._qt_plugins = self.get_value("android", "plugins").split(",")
+        elif dependent_plugins:
+            self._find_plugin_dependencies(dependent_plugins)
+            self.qt_plugins = list(set(dependent_plugins))
+
+        recipe_dir_temp = self.get_value("buildozer", "recipe_dir")
+        if recipe_dir_temp:
+            self.recipe_dir = Path(recipe_dir_temp)
+
+    @property
+    def qt_plugins(self):
+        return self._qt_plugins
+
+    @qt_plugins.setter
+    def qt_plugins(self, qt_plugins):
+        self._qt_plugins = qt_plugins
+        self.set_value("android", "plugins", ",".join(qt_plugins))
+
+    @property
+    def ndk_path(self):
+        return self._ndk_path
+
+    @ndk_path.setter
+    def ndk_path(self, ndk_path: Path):
+        self._ndk_path = ndk_path.resolve() if ndk_path else None
+        if self._ndk_path:
+            self.set_value("buildozer", "ndk_path", str(self._ndk_path))
+
+    @property
+    def sdk_path(self) -> Path:
+        return self._sdk_path
+
+    @sdk_path.setter
+    def sdk_path(self, sdk_path: Path):
+        self._sdk_path = sdk_path.resolve() if sdk_path else None
+        if self._sdk_path:
+            self.set_value("buildozer", "sdk_path", str(self._sdk_path))
+
+    @property
+    def arch(self):
+        return self._arch
+
+    @arch.setter
+    def arch(self, arch):
+        self._arch = arch
+        self.set_value("buildozer", "arch", arch)
+
+    @property
+    def mode(self):
+        return self._mode
+
+    @property
+    def modules(self):
+        return self._modules
+
+    @modules.setter
+    def modules(self, modules):
+        self._modules = modules
+        self.set_value("qt", "modules", ",".join(modules))
+
+    @property
+    def local_libs(self):
+        return self._local_libs
+
+    @local_libs.setter
+    def local_libs(self, local_libs):
+        self._local_libs = local_libs
+        self.set_value("buildozer", "local_libs", ",".join(local_libs))
+
+    @property
+    def recipe_dir(self):
+        return self._recipe_dir
+
+    @recipe_dir.setter
+    def recipe_dir(self, recipe_dir: Path):
+        self._recipe_dir = recipe_dir.resolve() if recipe_dir else None
+        if self._recipe_dir:
+            self.set_value("buildozer", "recipe_dir", str(self._recipe_dir))
+
+    def recipes_exist(self):
+        if not self._recipe_dir:
+            return False
+
+        pyside_recipe_dir = Path(self.recipe_dir) / "PySide6"
+        shiboken_recipe_dir = Path(self.recipe_dir) / "shiboken6"
+
+        return pyside_recipe_dir.is_dir() and shiboken_recipe_dir.is_dir()
+
+    @property
+    def jars_dir(self) -> Path:
+        return self._jars_dir
+
+    @jars_dir.setter
+    def jars_dir(self, jars_dir: Path):
+        self._jars_dir = jars_dir.resolve() if jars_dir else None
+        if self._jars_dir:
+            self.set_value("buildozer", "jars_dir", str(self._jars_dir))
+
+    @property
+    def wheel_pyside(self) -> Path:
+        return self._wheel_pyside
+
+    @wheel_pyside.setter
+    def wheel_pyside(self, wheel_pyside: Path):
+        self._wheel_pyside = wheel_pyside.resolve() if wheel_pyside else None
+        if self._wheel_pyside:
+            self.set_value("android", "wheel_pyside", str(self._wheel_pyside))
+
+    @property
+    def wheel_shiboken(self) -> Path:
+        return self._wheel_shiboken
+
+    @wheel_shiboken.setter
+    def wheel_shiboken(self, wheel_shiboken: Path):
+        self._wheel_shiboken = wheel_shiboken.resolve() if wheel_shiboken else None
+        if self._wheel_shiboken:
+            self.set_value("android", "wheel_shiboken", str(self._wheel_shiboken))
+
+    @property
+    def dependency_files(self):
+        return self._dependency_files
+
+    @dependency_files.setter
+    def dependency_files(self, dependency_files):
+        self._dependency_files = dependency_files
+
+    def _find_and_set_pysidemodules(self):
+        self.modules = find_pyside_modules(project_dir=self.project_dir,
+                                           extra_ignore_dirs=self.extra_ignore_dirs,
+                                           project_data=self.project_data)
+        logging.info("The following PySide modules were found from the python files of "
+                     f"the project {self.modules}")
+
+    def find_and_set_jars_dir(self):
+        """Extract out and copy .jar files to {generated_files_path}
+        """
+        if not self.dry_run:
+            logging.info("[DEPLOY] Extract and copy jar files from PySide6 wheel to "
+                         f"{self.generated_files_path}")
+            self.jars_dir = extract_and_copy_jar(wheel_path=self.wheel_pyside,
+                                                 generated_files_path=self.generated_files_path)
+
+    def _find_and_set_arch(self):
+        """Find architecture from wheel name
+        """
+        self.arch = get_wheel_android_arch(wheel=self.wheel_pyside)
+        if not self.arch:
+            raise RuntimeError("[DEPLOY] PySide wheel corrupted. Wheel name should end with"
+                               "platform name")
+
+    def _find_dependent_qt_modules(self):
+        """
+        Given pysidedeploy_config.modules, find all the other dependent Qt modules. This is
+        done by using llvm-readobj (readelf) to find the dependent libraries from the module
+        library.
+        """
+        dependent_modules = set()
+        all_dependencies = set()
+        lib_pattern = re.compile(f"libQt6(?P<mod_name>.*)_{self.arch}")
+
+        llvm_readobj = get_llvm_readobj(self.ndk_path)
+        if not llvm_readobj.exists():
+            raise FileNotFoundError(f"[DEPLOY] {llvm_readobj} does not exist."
+                                    "Finding Qt dependencies failed")
+
+        archive = zipfile.ZipFile(self.wheel_pyside)
+        lib_path_suffix = Path(str(self.qt_libs_path)).relative_to(self.wheel_pyside)
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            archive.extractall(tmpdir)
+            qt_libs_tmpdir = Path(tmpdir) / lib_path_suffix
+            # find the lib folder where Qt libraries are stored
+            for module_name in sorted(self.modules):
+                qt_module_path = qt_libs_tmpdir / f"libQt6{module_name}_{self.arch}.so"
+                if not qt_module_path.exists():
+                    raise FileNotFoundError(f"[DEPLOY] libQt6{module_name}_{self.arch}.so not found"
+                                            " inside the wheel")
+                find_lib_dependencies(llvm_readobj=llvm_readobj, lib_path=qt_module_path,
+                                      dry_run=self.dry_run,
+                                      used_dependencies=all_dependencies)
+
+        for dependency in all_dependencies:
+            match = lib_pattern.search(dependency)
+            if match:
+                module = match.group("mod_name")
+                if module not in self.modules:
+                    dependent_modules.add(module)
+
+        # check if the PySide6 binary for the Qt module actually exists
+        # eg: libQt6QmlModels.so exists and it includes QML types. Hence, it makes no
+        dependent_modules = [module for module in dependent_modules if module in
+                             get_all_pyside_modules()]
+        dependent_modules_str = ",".join(dependent_modules)
+        logging.info("[DEPLOY] The following extra dependencies were found:"
+                     f" {dependent_modules_str}")
+
+        return dependent_modules
+
+    def _find_and_set_dependency_files(self) -> List[zipfile.Path]:
+        """
+        Based on `modules`, returns the Qt6{module}_{arch}-android-dependencies.xml file, which
+        contains the various dependencies of the module, like permissions, plugins etc
+        """
+        needed_dependency_files = [(f"Qt{MAJOR_VERSION}{module}_{self.arch}"
+                                    "-android-dependencies.xml") for module in self.modules]
+
+        for dependency_file_name in needed_dependency_files:
+            dependency_file = self.qt_libs_path / dependency_file_name
+            if dependency_file.exists():
+                self._dependency_files.append(dependency_file)
+
+        logging.info("[DEPLOY] The following dependency files were found: "
+                     f"{*self._dependency_files,}")
+
+    def _find_local_libs(self):
+        local_libs = set()
+        plugins = set()
+        lib_pattern = re.compile(f"lib(?P<lib_name>.*)_{self.arch}")
+        for dependency_file in self._dependency_files:
+            xml_content = dependency_file.read_text()
+            root = ET.fromstring(xml_content)
+            for local_lib in root.iter("lib"):
+
+                if 'file' not in local_lib.attrib:
+                    if 'name' not in local_lib.attrib:
+                        logging.warning("[DEPLOY] Invalid android dependency file"
+                                        f" {str(dependency_file)}")
+                    continue
+
+                file = local_lib.attrib['file']
+                if file.endswith(".so"):
+                    # file_name starts with lib and ends with the platform name
+                    # eg: lib<lib_name>_x86_64.so
+                    file_name = Path(file).stem
+
+                    # we only need lib_name, because lib and arch gets re-added by
+                    # python-for-android
+                    match = lib_pattern.search(file_name)
+                    if match:
+                        lib_name = match.group("lib_name")
+                        local_libs.add(lib_name)
+                        if lib_name.startswith("plugins"):
+                            plugin_name = lib_name.split('plugins_', 1)[1]
+                            plugins.add(plugin_name)
+
+        return list(local_libs), list(plugins)
+
+    def _find_plugin_dependencies(self, dependent_plugins: List[str]):
+        # The `bundled` element in the dependency xml files points to the folder where
+        # additional dependencies for the application exists. Inspecting the depenency files
+        # in android, this always points to the specific Qt plugin dependency folder.
+        # eg: for application using Qt Multimedia, this looks like:
+        # <bundled file="./plugins/multimedia" />
+        # The code recusively checks all these dependent folders and adds the necessary plugins
+        # as dependencies
+        lib_pattern = re.compile(f"libplugins_(?P<plugin_name>.*)_{self.arch}.so")
+        for dependency_file in self._dependency_files:
+            xml_content = dependency_file.read_text()
+            root = ET.fromstring(xml_content)
+            for bundled_element in root.iter("bundled"):
+                # the attribute 'file' can be misleading, but it always points to the plugin
+                # folder on inspecting the dependency files
+                if 'file' not in bundled_element.attrib:
+                    logging.warning("[DEPLOY] Invalid Android dependency file"
+                                    f" {str(dependency_file)}")
+                    continue
+
+                # from "./plugins/multimedia" to absolute path in wheel
+                plugin_module_folder = bundled_element.attrib['file']
+                # they all should start with `./plugins`
+                if plugin_module_folder.startswith("./plugins"):
+                    plugin_module_folder = plugin_module_folder.partition("./plugins/")[2]
+                else:
+                    continue
+
+                absolute_plugin_module_folder = (self.qt_libs_path.parent / "plugins"
+                                                 / plugin_module_folder)
+
+                if not absolute_plugin_module_folder.is_dir():
+                    logging.warning(f"[DEPLOY] Qt plugin folder '{plugin_module_folder}' does not"
+                                    " exist or is not a directory for this Android platform")
+                    continue
+
+                for plugin in absolute_plugin_module_folder.iterdir():
+                    plugin_name = plugin.name
+                    if plugin_name.endswith(".so") and plugin_name.startswith("libplugins"):
+                        # we only need part of plugin_name, because `lib` prefix and `arch` suffix
+                        # gets re-added by python-for-android
+                        match = lib_pattern.search(plugin_name)
+                        if match:
+                            plugin_infix_name = match.group("plugin_name")
+                            if plugin_infix_name not in dependent_plugins:
+                                dependent_plugins.append(plugin_infix_name)
+
+    def verify_and_set_recipe_dir(self):
+        # create recipes
+        # https://python-for-android.readthedocs.io/en/latest/recipes/
+        # These recipes are manually added through buildozer.spec file to be used by
+        # python_for_android while building the distribution
+
+        if not self.recipes_exist() and not self.dry_run:
+            logging.info("[DEPLOY] Creating p4a recipes for PySide6 and shiboken6")
+            version = Wheel(self.wheel_pyside).version
+            create_recipe(version=version, component=f"PySide{MAJOR_VERSION}",
+                          wheel_path=self.wheel_pyside,
+                          generated_files_path=self.generated_files_path,
+                          qt_modules=self.modules,
+                          local_libs=self.local_libs,
+                          plugins=self.qt_plugins)
+            create_recipe(version=version, component=f"shiboken{MAJOR_VERSION}",
+                          wheel_path=self.wheel_shiboken,
+                          generated_files_path=self.generated_files_path)
+            self.recipe_dir = ((self.generated_files_path
+                                / "recipes").resolve())
diff --git a/sources/pyside-tools/deploy_lib/android/android_helper.py b/sources/pyside-tools/deploy_lib/android/android_helper.py
new file mode 100644
index 000000000..7d2f5d575
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/android/android_helper.py
@@ -0,0 +1,151 @@
+# 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 logging
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Set
+from zipfile import ZipFile
+
+from jinja2 import Environment, FileSystemLoader
+
+from .. import run_command
+
+
+@dataclass
+class AndroidData:
+    """
+    Dataclass to store all the Android data obtained through cli
+    """
+    wheel_pyside: Path
+    wheel_shiboken: Path
+    ndk_path: Path
+    sdk_path: Path
+
+
+def create_recipe(version: str, component: str, wheel_path: str, generated_files_path: Path,
+                  qt_modules: List[str] = None, local_libs: List[str] = None,
+                  plugins: List[str] = None):
+    '''
+    Create python_for_android recipe for PySide6 and shiboken6
+    '''
+    qt_plugins = []
+    if plugins:
+        # split plugins based on category
+        for plugin in plugins:
+            plugin_category, plugin_name = plugin.split('_', 1)
+            qt_plugins.append((plugin_category, plugin_name))
+
+    qt_local_libs = []
+    if local_libs:
+        qt_local_libs = [local_lib for local_lib in local_libs if local_lib.startswith("Qt6")]
+
+    rcp_tmpl_path = Path(__file__).parent / "recipes" / f"{component}"
+    environment = Environment(loader=FileSystemLoader(rcp_tmpl_path))
+    template = environment.get_template("__init__.tmpl.py")
+    content = template.render(
+        version=version,
+        wheel_path=wheel_path,
+        qt_modules=qt_modules,
+        qt_local_libs=qt_local_libs,
+        qt_plugins=qt_plugins
+    )
+
+    recipe_path = generated_files_path / "recipes" / f"{component}"
+    recipe_path.mkdir(parents=True, exist_ok=True)
+    logging.info(f"[DEPLOY] Writing {component} recipe into {str(recipe_path)}")
+    with open(recipe_path / "__init__.py", mode="w", encoding="utf-8") as recipe:
+        recipe.write(content)
+
+
+def extract_and_copy_jar(wheel_path: Path, generated_files_path: Path) -> str:
+    '''
+    extracts the PySide6 wheel and copies the 'jar' folder to 'generated_files_path'.
+    These .jar files are added to the buildozer.spec file to be used later by buildozer
+    '''
+    jar_path = generated_files_path / "jar"
+    jar_path.mkdir(parents=True, exist_ok=True)
+    archive = ZipFile(wheel_path)
+    jar_files = [file for file in archive.namelist() if file.startswith("PySide6/jar")]
+    for file in jar_files:
+        archive.extract(file, jar_path)
+    return (jar_path / "PySide6" / "jar").resolve() if jar_files else None
+
+
+def get_wheel_android_arch(wheel: Path):
+    '''
+    Get android architecture from wheel
+    '''
+    supported_archs = ["aarch64", "armv7a", "i686", "x86_64"]
+    for arch in supported_archs:
+        if arch in wheel.stem:
+            return arch
+
+    return None
+
+
+def get_llvm_readobj(ndk_path: Path) -> Path:
+    '''
+    Return the path to llvm_readobj from the Android Ndk
+    '''
+    # TODO: Requires change if Windows platform supports Android Deployment or if we
+    # support host other than linux-x86_64
+    return (ndk_path / "toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-readobj")
+
+
+def find_lib_dependencies(llvm_readobj: Path, lib_path: Path, used_dependencies: Set[str] = None,
+                          dry_run: bool = False):
+    """
+    Find all the Qt dependencies of a library using llvm_readobj
+    """
+    if lib_path.name in used_dependencies:
+        return
+
+    used_dependencies.add(lib_path.name)
+
+    command = [str(llvm_readobj), "--needed-libs", str(lib_path)]
+
+    # even if dry_run is given, we need to run the actual command to see all the dependencies
+    # for which llvm-readelf is run.
+    if dry_run:
+        _, output = run_command(command=command, dry_run=dry_run, fetch_output=True)
+    _, output = run_command(command=command, dry_run=False, fetch_output=True)
+
+    dependencies = set()
+    neededlibraries_found = False
+    for line in output.splitlines():
+        line = line.decode("utf-8").lstrip()
+        if line.startswith("NeededLibraries") and not neededlibraries_found:
+            neededlibraries_found = True
+        if neededlibraries_found and line.startswith("libQt"):
+            dependencies.add(line)
+            used_dependencies.add(line)
+            dependent_lib_path = lib_path.parent / line
+            find_lib_dependencies(llvm_readobj, dependent_lib_path, used_dependencies, dry_run)
+
+    if dependencies:
+        logging.info(f"[DEPLOY] Following dependencies found for {lib_path.stem}: {dependencies}")
+    else:
+        logging.info(f"[DEPLOY] No Qt dependencies found for {lib_path.stem}")
+
+
+def find_qtlibs_in_wheel(wheel_pyside: Path):
+    """
+    Find the path to Qt/lib folder inside the wheel.
+    """
+    archive = ZipFile(wheel_pyside)
+    qt_libs_path = wheel_pyside / "PySide6/Qt/lib"
+    qt_libs_path = zipfile.Path(archive, at=qt_libs_path)
+    if not qt_libs_path.exists():
+        for file in archive.namelist():
+            # the dependency files are inside the libs folder
+            if file.endswith("android-dependencies.xml"):
+                qt_libs_path = zipfile.Path(archive, at=file).parent
+                # all dependency files are in the same path
+                break
+
+    if not qt_libs_path:
+        raise FileNotFoundError("[DEPLOY] Unable to find Qt libs folder inside the wheel")
+
+    return qt_libs_path
diff --git a/sources/pyside-tools/deploy_lib/android/buildozer.py b/sources/pyside-tools/deploy_lib/android/buildozer.py
new file mode 100644
index 000000000..0c314c356
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/android/buildozer.py
@@ -0,0 +1,147 @@
+# 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 sys
+import logging
+import xml.etree.ElementTree as ET
+import zipfile
+from pathlib import Path
+from typing import List
+
+from . import AndroidConfig
+from .. import BaseConfig, run_command
+
+
+class BuildozerConfig(BaseConfig):
+    def __init__(self, buildozer_spec_file: Path, pysidedeploy_config: AndroidConfig):
+        super().__init__(buildozer_spec_file, comment_prefixes="#")
+        self.set_value("app", "title", pysidedeploy_config.title)
+        self.set_value("app", "package.name", pysidedeploy_config.title)
+        self.set_value("app", "package.domain",
+                       f"org.{pysidedeploy_config.title}")
+
+        include_exts = self.get_value("app", "source.include_exts")
+        include_exts = f"{include_exts},qml,js"
+        self.set_value("app", "source.include_exts", include_exts, raise_warning=False)
+
+        self.set_value("app", "requirements", "python3,shiboken6,PySide6")
+
+        # android platform specific
+        if pysidedeploy_config.ndk_path:
+            self.set_value("app", "android.ndk_path", str(pysidedeploy_config.ndk_path))
+
+        if pysidedeploy_config.sdk_path:
+            self.set_value("app", "android.sdk_path", str(pysidedeploy_config.sdk_path))
+
+        self.set_value("app", "android.archs", pysidedeploy_config.arch)
+
+        # p4a changes
+        self.set_value("app", "p4a.bootstrap", "qt")
+        self.set_value('app', "p4a.local_recipes", str(pysidedeploy_config.recipe_dir))
+
+        # add p4a branch
+        # by default the master branch is used
+        # https://github.com/kivy/python-for-android/commit/b92522fab879dbfc0028966ca3c59ef46ab7767d
+        # has not been merged to master yet. So, we use the develop branch for now
+        # TODO: remove this once the above commit is merged to master
+        self.set_value("app", "p4a.branch", "develop")
+
+        # add permissions
+        permissions = self.__find_permissions(pysidedeploy_config.dependency_files)
+        permissions = ", ".join(permissions)
+        self.set_value("app", "android.permissions", permissions)
+
+        # add jars and initClasses for the jars
+        jars, init_classes = self.__find_jars(pysidedeploy_config.dependency_files,
+                                              pysidedeploy_config.jars_dir)
+        self.set_value("app", "android.add_jars", ",".join(jars))
+
+        # extra arguments specific to Qt
+        modules = ",".join(pysidedeploy_config.modules)
+        local_libs = ",".join(pysidedeploy_config.local_libs)
+        init_classes = ",".join(init_classes)
+        extra_args = (f"--qt-libs={modules} --load-local-libs={local_libs}"
+                      f" --init-classes={init_classes}")
+        self.set_value("app", "p4a.extra_args", extra_args)
+
+        # TODO: does not work atm. Seems like a bug with buildozer
+        # change buildozer build_dir
+        # self.set_value("buildozer", "build_dir", str(build_dir.relative_to(Path.cwd())))
+
+        # change final apk/aab path
+        self.set_value("buildozer", "bin_dir", str(pysidedeploy_config.exe_dir.resolve()))
+
+        # set application icon
+        self.set_value("app", "icon.filename", pysidedeploy_config.icon)
+
+        self.update_config()
+
+    def __find_permissions(self, dependency_files: List[zipfile.Path]):
+        permissions = set()
+        for dependency_file in dependency_files:
+            xml_content = dependency_file.read_text()
+            root = ET.fromstring(xml_content)
+            for permission in root.iter("permission"):
+                permissions.add(permission.attrib['name'])
+        return permissions
+
+    def __find_jars(self, dependency_files: List[zipfile.Path], jars_dir: Path):
+        jars, init_classes = set(), set()
+        for dependency_file in dependency_files:
+            xml_content = dependency_file.read_text()
+            root = ET.fromstring(xml_content)
+            for jar in root.iter("jar"):
+                jar_file = jar.attrib['file']
+                if jar_file.startswith("jar/"):
+                    jar_file_name = jar_file[4:]
+                    if (jars_dir / jar_file_name).exists():
+                        jars.add(str(jars_dir / jar_file_name))
+                    else:
+                        logging.warning(f"[DEPLOY] Unable to include {jar_file}. "
+                                        f"{jar_file} does not exist in {jars_dir}")
+                        continue
+                else:
+                    logging.warning(f"[DEPLOY] Unable to include {jar_file}. "
+                                    "All jar file paths should begin with 'jar/'")
+                    continue
+
+                jar_init_class = jar.attrib.get('initClass')
+                if jar_init_class:
+                    init_classes.add(jar_init_class)
+
+        # add the jar with all the activity and service java files
+        # this is created from Qt for Python instead of Qt
+        # The initClasses for this are already taken care of by python-for-android
+        android_bindings_jar = jars_dir / "Qt6AndroidBindings.jar"
+        if android_bindings_jar.exists():
+            jars.add(str(android_bindings_jar))
+        else:
+            raise FileNotFoundError(f"{android_bindings_jar} not found in wheel")
+
+        return jars, init_classes
+
+
+class Buildozer:
+    dry_run = False
+
+    @staticmethod
+    def initialize(pysidedeploy_config: AndroidConfig):
+        project_dir = Path(pysidedeploy_config.project_dir)
+        buildozer_spec = project_dir / "buildozer.spec"
+        if buildozer_spec.exists():
+            logging.warning(f"[DEPLOY] buildozer.spec already present in {str(project_dir)}."
+                            "Using it")
+            return
+
+        # creates buildozer.spec config file
+        command = [sys.executable, "-m", "buildozer", "init"]
+        run_command(command=command, dry_run=Buildozer.dry_run)
+        if not Buildozer.dry_run:
+            if not buildozer_spec.exists():
+                raise RuntimeError(f"buildozer.spec not found in {Path.cwd()}")
+            BuildozerConfig(buildozer_spec, pysidedeploy_config)
+
+    @staticmethod
+    def create_executable(mode: str):
+        command = [sys.executable, "-m", "buildozer", "android", mode]
+        run_command(command=command, dry_run=Buildozer.dry_run)
diff --git a/sources/pyside-tools/deploy_lib/android/recipes/PySide6/__init__.tmpl.py b/sources/pyside-tools/deploy_lib/android/recipes/PySide6/__init__.tmpl.py
new file mode 100644
index 000000000..8a8615798
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/android/recipes/PySide6/__init__.tmpl.py
@@ -0,0 +1,64 @@
+# 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 shutil
+import zipfile
+from pathlib import Path
+
+from pythonforandroid.logger import info
+from pythonforandroid.recipe import PythonRecipe
+
+
+class PySideRecipe(PythonRecipe):
+    version = '{{ version }}'
+    wheel_path = '{{ wheel_path }}'
+    depends = ["shiboken6"]
+    call_hostpython_via_targetpython = False
+    install_in_hostpython = False
+
+    def build_arch(self, arch):
+        """Unzip the wheel and copy into site-packages of target"""
+
+        info("Copying libc++_shared.so from SDK to be loaded on startup")
+        libcpp_path = f"{self.ctx.ndk.sysroot_lib_dir}/{arch.command_prefix}/libc++_shared.so"
+        shutil.copyfile(libcpp_path, Path(self.ctx.get_libs_dir(arch.arch)) / "libc++_shared.so")
+
+        info(f"Installing {self.name} into site-packages")
+        with zipfile.ZipFile(self.wheel_path, "r") as zip_ref:
+            info("Unzip wheels and copy into {}".format(self.ctx.get_python_install_dir(arch.arch)))
+            zip_ref.extractall(self.ctx.get_python_install_dir(arch.arch))
+
+        lib_dir = Path(f"{self.ctx.get_python_install_dir(arch.arch)}/PySide6/Qt/lib")
+
+        info("Copying Qt libraries to be loaded on startup")
+        shutil.copytree(lib_dir, self.ctx.get_libs_dir(arch.arch), dirs_exist_ok=True)
+        shutil.copyfile(lib_dir.parent.parent / "libpyside6.abi3.so",
+                        Path(self.ctx.get_libs_dir(arch.arch)) / "libpyside6.abi3.so")
+
+        {% for module in qt_modules %}  # noqa: E999
+        shutil.copyfile(lib_dir.parent.parent / f"Qt{{ module }}.abi3.so",
+                        Path(self.ctx.get_libs_dir(arch.arch)) / "Qt{{ module }}.abi3.so")
+        {% if module == "Qml" -%}  # noqa: E999
+        shutil.copyfile(lib_dir.parent.parent / "libpyside6qml.abi3.so",
+                        Path(self.ctx.get_libs_dir(arch.arch)) / "libpyside6qml.abi3.so")
+        {% endif %}  # noqa: E999
+        {% endfor %}  # noqa: E999
+
+        {% for lib in qt_local_libs %}  # noqa: E999
+        lib_path = lib_dir / f"lib{{ lib }}_{arch.arch}.so"
+        if lib_path.exists():
+            shutil.copyfile(lib_path,
+                            Path(self.ctx.get_libs_dir(arch.arch)) / f"lib{{ lib }}_{arch.arch}.so")
+        {% endfor %}  # noqa: E999
+
+        {% for plugin_category,plugin_name in qt_plugins %}  # noqa: E999
+        plugin_path = (lib_dir.parent / "plugins" / "{{ plugin_category }}" /
+                      f"libplugins_{{ plugin_category }}_{{ plugin_name }}_{arch.arch}.so")
+        if plugin_path.exists():
+            shutil.copyfile(plugin_path,
+                            (Path(self.ctx.get_libs_dir(arch.arch)) /
+                             f"libplugins_{{ plugin_category }}_{{ plugin_name }}_{arch.arch}.so"))
+        {% endfor %}  # noqa: E999
+
+
+recipe = PySideRecipe()
diff --git a/sources/pyside-tools/deploy_lib/android/recipes/shiboken6/__init__.tmpl.py b/sources/pyside-tools/deploy_lib/android/recipes/shiboken6/__init__.tmpl.py
new file mode 100644
index 000000000..d6ab037bf
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/android/recipes/shiboken6/__init__.tmpl.py
@@ -0,0 +1,31 @@
+# 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 shutil
+import zipfile
+from pathlib import Path
+
+from pythonforandroid.logger import info
+from pythonforandroid.recipe import PythonRecipe
+
+
+class ShibokenRecipe(PythonRecipe):
+    version = '{{ version }}'
+    wheel_path = '{{ wheel_path }}'
+
+    call_hostpython_via_targetpython = False
+    install_in_hostpython = False
+
+    def build_arch(self, arch):
+        ''' Unzip the wheel and copy into site-packages of target'''
+        info('Installing {} into site-packages'.format(self.name))
+        with zipfile.ZipFile(self.wheel_path, 'r') as zip_ref:
+            info('Unzip wheels and copy into {}'.format(self.ctx.get_python_install_dir(arch.arch)))
+            zip_ref.extractall(self.ctx.get_python_install_dir(arch.arch))
+
+        lib_dir = Path(f"{self.ctx.get_python_install_dir(arch.arch)}/shiboken6")
+        shutil.copyfile(lib_dir / "libshiboken6.abi3.so",
+                        Path(self.ctx.get_libs_dir(arch.arch)) / "libshiboken6.abi3.so")
+
+
+recipe = ShibokenRecipe()
diff --git a/sources/pyside-tools/deploy_lib/commands.py b/sources/pyside-tools/deploy_lib/commands.py
new file mode 100644
index 000000000..3a7e2a2e2
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/commands.py
@@ -0,0 +1,60 @@
+# 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 json
+import subprocess
+import sys
+from pathlib import Path
+from typing import List
+
+"""
+All utility functions for deployment
+"""
+
+
+def run_command(command, dry_run: bool, fetch_output: bool = False):
+    command_str = " ".join([str(cmd) for cmd in command])
+    output = None
+    is_windows = (sys.platform == "win32")
+    try:
+        if not dry_run:
+            if fetch_output:
+                output = subprocess.check_output(command, shell=is_windows)
+            else:
+                subprocess.check_call(command, shell=is_windows)
+        else:
+            print(command_str + "\n")
+    except FileNotFoundError as error:
+        raise FileNotFoundError(f"[DEPLOY] {error.filename} not found")
+    except subprocess.CalledProcessError as error:
+        raise RuntimeError(
+            f"[DEPLOY] Command {command_str} failed with error {error} and return_code"
+            f"{error.returncode}"
+        )
+    except Exception as error:
+        raise RuntimeError(f"[DEPLOY] Command {command_str} failed with error {error}")
+
+    return command_str, output
+
+
+def run_qmlimportscanner(qml_files: List[Path], dry_run: bool):
+    """
+        Runs pyside6-qmlimportscanner to find all the imported qml modules
+    """
+    if not qml_files:
+        return []
+
+    qml_modules = []
+    cmd = ["pyside6-qmlimportscanner", "-qmlFiles"]
+    cmd.extend([str(qml_file) for qml_file in qml_files])
+
+    if dry_run:
+        run_command(command=cmd, dry_run=True)
+
+    # we need to run qmlimportscanner during dry_run as well to complete the
+    # command being run by nuitka
+    _, json_string = run_command(command=cmd, dry_run=False, fetch_output=True)
+    json_string = json_string.decode("utf-8")
+    json_array = json.loads(json_string)
+    qml_modules = [item['name'] for item in json_array if item['type'] == "module"]
+    return qml_modules
diff --git a/sources/pyside-tools/deploy_lib/config.py b/sources/pyside-tools/deploy_lib/config.py
new file mode 100644
index 000000000..d59dd92ad
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/config.py
@@ -0,0 +1,459 @@
+# 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
+import configparser
+import logging
+import warnings
+from configparser import ConfigParser
+from typing import List
+from pathlib import Path
+
+from project import ProjectData
+from . import (DEFAULT_APP_ICON, find_pyside_modules, find_permission_categories,
+               QtDependencyReader, run_qmlimportscanner)
+
+# Some QML plugins like QtCore are excluded from this list as they don't contribute much to
+# executable size. Excluding them saves the extra processing of checking for them in files
+EXCLUDED_QML_PLUGINS = {"QtQuick", "QtQuick3D", "QtCharts", "QtWebEngine", "QtTest", "QtSensors"}
+
+PERMISSION_MAP = {"Bluetooth": "NSBluetoothAlwaysUsageDescription:BluetoothAccess",
+                  "Camera": "NSCameraUsageDescription:CameraAccess",
+                  "Microphone": "NSMicrophoneUsageDescription:MicrophoneAccess",
+                  "Contacts": "NSContactsUsageDescription:ContactsAccess",
+                  "Calendar": "NSCalendarsUsageDescription:CalendarAccess",
+                  # for iOS NSLocationWhenInUseUsageDescription and
+                  # NSLocationAlwaysAndWhenInUseUsageDescription are also required.
+                  "Location": "NSLocationUsageDescription:LocationAccess",
+                  }
+
+
+class BaseConfig:
+    """Wrapper class around any .spec file with function to read and set values for the .spec file
+    """
+    def __init__(self, config_file: Path, comment_prefixes: str = "/",
+                 existing_config_file: bool = False) -> None:
+        self.config_file = config_file
+        self.existing_config_file = existing_config_file
+        self.parser = ConfigParser(comment_prefixes=comment_prefixes, strict=False,
+                                   allow_no_value=True)
+        self.parser.read(self.config_file)
+
+    def update_config(self):
+        logging.info(f"[DEPLOY] Creating {self.config_file}")
+        with open(self.config_file, "w+") as config_file:
+            self.parser.write(config_file, space_around_delimiters=True)
+
+    def set_value(self, section: str, key: str, new_value: str, raise_warning: bool = True):
+        try:
+            current_value = self.get_value(section, key, ignore_fail=True)
+            if current_value != new_value:
+                self.parser.set(section, key, new_value)
+        except configparser.NoOptionError:
+            if raise_warning:
+                logging.warning(f"[DEPLOY] Key {key} does not exist")
+        except configparser.NoSectionError:
+            if raise_warning:
+                logging.warning(f"[DEPLOY] Section {section} does not exist")
+
+    def get_value(self, section: str, key: str, ignore_fail: bool = False):
+        try:
+            return self.parser.get(section, key)
+        except configparser.NoOptionError:
+            if not ignore_fail:
+                logging.warning(f"[DEPLOY] Key {key} does not exist")
+        except configparser.NoSectionError:
+            if not ignore_fail:
+                logging.warning(f"[DEPLOY] Section {section} does not exist")
+
+
+class Config(BaseConfig):
+    """
+    Wrapper class around pysidedeploy.spec file, whose options are used to control the executable
+    creation
+    """
+
+    def __init__(self, config_file: Path, source_file: Path, python_exe: Path, dry_run: bool,
+                 existing_config_file: bool = False, extra_ignore_dirs: List[str] = None):
+        super().__init__(config_file=config_file, existing_config_file=existing_config_file)
+
+        self.extra_ignore_dirs = extra_ignore_dirs
+        self._dry_run = dry_run
+        self.qml_modules = set()
+        # set source_file
+        self.source_file = Path(
+            self.set_or_fetch(config_property_val=source_file, config_property_key="input_file")
+        ).resolve()
+
+        # set python path
+        self.python_path = Path(
+            self.set_or_fetch(
+                config_property_val=python_exe,
+                config_property_key="python_path",
+                config_property_group="python",
+            )
+        )
+
+        self.title = self.get_value("app", "title")
+
+        # set application icon
+        config_icon = self.get_value("app", "icon")
+        if config_icon:
+            self.icon = str(Path(config_icon).resolve())
+        else:
+            self.icon = DEFAULT_APP_ICON
+
+        self.project_dir = None
+        if self.get_value("app", "project_dir"):
+            self.project_dir = Path(self.get_value("app", "project_dir")).absolute()
+        else:
+            self._find_and_set_project_dir()
+
+        self.exe_dir = None
+        if self.get_value("app", "exec_directory"):
+            self.exe_dir = Path(self.get_value("app", "exec_directory")).absolute()
+        else:
+            self._find_and_set_exe_dir()
+
+        self.project_data: ProjectData = None
+        if self.get_value("app", "project_file"):
+            project_file = Path(self.get_value("app", "project_file")).absolute()
+            self.project_data = ProjectData(project_file=project_file)
+        else:
+            self._find_and_set_project_file()
+
+        self.qml_files = []
+        config_qml_files = self.get_value("qt", "qml_files")
+        if config_qml_files and self.project_dir and self.existing_config_file:
+            self.qml_files = [Path(self.project_dir) / file for file in config_qml_files.split(",")]
+        else:
+            self._find_and_set_qml_files()
+
+        self.excluded_qml_plugins = []
+        if self.get_value("qt", "excluded_qml_plugins") and self.existing_config_file:
+            self.excluded_qml_plugins = self.get_value("qt", "excluded_qml_plugins").split(",")
+        else:
+            self._find_and_set_excluded_qml_plugins()
+
+        self._generated_files_path = self.project_dir / "deployment"
+
+        self.modules = []
+
+    def set_or_fetch(self, config_property_val, config_property_key, config_property_group="app"):
+        """
+        Write to config_file if 'config_property_key' is known without config_file
+        Fetch and return from config_file if 'config_property_key' is unknown, but
+        config_file exists
+        Otherwise, raise an exception
+        """
+        if config_property_val:
+            self.set_value(config_property_group, config_property_key, str(config_property_val))
+            return config_property_val
+        elif self.get_value(config_property_group, config_property_key):
+            return self.get_value(config_property_group, config_property_key)
+        else:
+            raise RuntimeError(
+                f"[DEPLOY] No {config_property_key} specified in config file or as cli option"
+            )
+
+    @property
+    def dry_run(self):
+        return self._dry_run
+
+    @property
+    def generated_files_path(self):
+        return self._generated_files_path
+
+    @property
+    def qml_files(self):
+        return self._qml_files
+
+    @qml_files.setter
+    def qml_files(self, qml_files):
+        self._qml_files = qml_files
+
+    @property
+    def project_dir(self):
+        return self._project_dir
+
+    @project_dir.setter
+    def project_dir(self, project_dir):
+        self._project_dir = project_dir
+
+    @property
+    def title(self):
+        return self._title
+
+    @title.setter
+    def title(self, title):
+        self._title = title
+        self.set_value("app", "title", title)
+
+    @property
+    def icon(self):
+        return self._icon
+
+    @icon.setter
+    def icon(self, icon):
+        self._icon = icon
+        self.set_value("app", "icon", icon)
+
+    @property
+    def source_file(self):
+        return self._source_file
+
+    @source_file.setter
+    def source_file(self, source_file: Path):
+        self._source_file = source_file
+
+    @property
+    def python_path(self):
+        return self._python_path
+
+    @python_path.setter
+    def python_path(self, python_path: Path):
+        self._python_path = python_path
+
+    @property
+    def extra_args(self):
+        return self.get_value("nuitka", "extra_args")
+
+    @extra_args.setter
+    def extra_args(self, extra_args):
+        self.set_value("nuitka", "extra_args", extra_args)
+
+    @property
+    def excluded_qml_plugins(self):
+        return self._excluded_qml_plugins
+
+    @excluded_qml_plugins.setter
+    def excluded_qml_plugins(self, excluded_qml_plugins):
+        self._excluded_qml_plugins = excluded_qml_plugins
+
+    @property
+    def exe_dir(self):
+        return self._exe_dir
+
+    @exe_dir.setter
+    def exe_dir(self, exe_dir: Path):
+        self._exe_dir = exe_dir
+
+    @property
+    def modules(self):
+        return self._modules
+
+    @modules.setter
+    def modules(self, modules):
+        self._modules = modules
+        self.set_value("qt", "modules", ",".join(modules))
+
+    def _find_and_set_qml_files(self):
+        """Fetches all the qml_files in the folder and sets them if the
+        field qml_files is empty in the config_dir"""
+
+        if self.project_data:
+            qml_files = self.project_data.qml_files
+            for sub_project_file in self.project_data.sub_projects_files:
+                qml_files.extend(ProjectData(project_file=sub_project_file).qml_files)
+            self.qml_files = qml_files
+        else:
+            qml_files_temp = None
+            if self.source_file and self.python_path:
+                if not self.qml_files:
+                    qml_files_temp = list(self.source_file.parent.glob("**/*.qml"))
+
+                # add all QML files, excluding the ones shipped with installed PySide6
+                # The QML files shipped with PySide6 gets added if venv is used,
+                # because of recursive glob
+                if self.python_path.parent.parent == self.source_file.parent:
+                    # python venv path is inside the main source dir
+                    qml_files_temp = list(
+                        set(qml_files_temp) - set(self.python_path.parent.parent.rglob("*.qml"))
+                    )
+
+                if len(qml_files_temp) > 500:
+                    if "site-packages" in str(qml_files_temp[-1]):
+                        raise RuntimeError(
+                            "You are including a lot of QML files from a local virtual env."
+                            " This can lead to errors in deployment."
+                        )
+                    else:
+                        warnings.warn(
+                            "You seem to include a lot of QML files. This can lead to errors in "
+                            "deployment."
+                        )
+
+                if qml_files_temp:
+                    extra_qml_files = [Path(file) for file in qml_files_temp]
+                    self.qml_files.extend(extra_qml_files)
+        if self.qml_files:
+            self.set_value(
+                "qt",
+                "qml_files",
+                ",".join([str(file.absolute().relative_to(self.project_dir))
+                          for file in self.qml_files]),
+            )
+            logging.info("[DEPLOY] QML files identified and set in config_file")
+
+    def _find_and_set_project_dir(self):
+        # there is no other way to find the project_dir than assume it is the parent directory
+        # of source_file
+        self.project_dir = self.source_file.parent
+
+        # update input_file path
+        self.set_value("app", "input_file", str(self.source_file.relative_to(self.project_dir)))
+
+        if self.project_dir != Path.cwd():
+            self.set_value("app", "project_dir", str(self.project_dir))
+        else:
+            self.set_value("app", "project_dir", str(self.project_dir.relative_to(Path.cwd())))
+
+    def _find_and_set_project_file(self):
+        if self.project_dir:
+            files = list(self.project_dir.glob("*.pyproject"))
+        else:
+            logging.exception("[DEPLOY] Project directory not set in config file")
+            raise
+
+        if not files:
+            logging.info("[DEPLOY] No .pyproject file found. Project file not set")
+        elif len(files) > 1:
+            logging.warning("DEPLOY: More that one .pyproject files found. Project file not set")
+            raise
+        else:
+            self.project_data = ProjectData(files[0])
+            self.set_value("app", "project_file", str(files[0].relative_to(self.project_dir)))
+            logging.info(f"[DEPLOY] Project file {files[0]} found and set in config file")
+
+    def _find_and_set_excluded_qml_plugins(self):
+        if self.qml_files:
+            self.qml_modules = set(run_qmlimportscanner(qml_files=self.qml_files,
+                                                        dry_run=self.dry_run))
+            self.excluded_qml_plugins = EXCLUDED_QML_PLUGINS.difference(self.qml_modules)
+
+            # needed for dry_run testing
+            self.excluded_qml_plugins = sorted(self.excluded_qml_plugins)
+
+            if self.excluded_qml_plugins:
+                self.set_value("qt", "excluded_qml_plugins", ",".join(self.excluded_qml_plugins))
+
+    def _find_and_set_exe_dir(self):
+        if self.project_dir == Path.cwd():
+            self.exe_dir = self.project_dir.relative_to(Path.cwd())
+        else:
+            self.exe_dir = self.project_dir
+        self.exe_dir = Path(
+            self.set_or_fetch(
+                config_property_val=self.exe_dir, config_property_key="exec_directory"
+            )
+        ).absolute()
+
+    def _find_and_set_pysidemodules(self):
+        self.modules = find_pyside_modules(project_dir=self.project_dir,
+                                           extra_ignore_dirs=self.extra_ignore_dirs,
+                                           project_data=self.project_data)
+        logging.info("The following PySide modules were found from the Python files of "
+                     f"the project {self.modules}")
+
+    def _find_and_set_qtquick_modules(self):
+        """Identify if QtQuick is used in QML files and add them as dependency
+        """
+        extra_modules = []
+        if not self.qml_modules:
+            self.qml_modules = set(run_qmlimportscanner(qml_files=self.qml_files,
+                                                        dry_run=self.dry_run))
+
+        if "QtQuick" in self.qml_modules:
+            extra_modules.append("Quick")
+
+        if "QtQuick.Controls" in self.qml_modules:
+            extra_modules.append("QuickControls2")
+
+        self.modules += extra_modules
+
+
+class DesktopConfig(Config):
+    """Wrapper class around pysidedeploy.spec, but specific to Desktop deployment
+    """
+    def __init__(self, config_file: Path, source_file: Path, python_exe: Path, dry_run: bool,
+                 existing_config_file: bool = False, extra_ignore_dirs: List[str] = None):
+        super().__init__(config_file, source_file, python_exe, dry_run, existing_config_file,
+                         extra_ignore_dirs)
+        self.dependency_reader = QtDependencyReader(dry_run=self.dry_run)
+        if self.get_value("qt", "modules"):
+            self.modules = self.get_value("qt", "modules").split(",")
+        else:
+            self._find_and_set_pysidemodules()
+            self._find_and_set_qtquick_modules()
+            self._find_dependent_qt_modules()
+
+        self._qt_plugins = []
+        if self.get_value("qt", "plugins"):
+            self._qt_plugins = self.get_value("qt", "plugins").split(",")
+        else:
+            self.qt_plugins = self.dependency_reader.find_plugin_dependencies(self.modules,
+                                                                              python_exe)
+
+        self._permissions = []
+        if sys.platform == "darwin":
+            nuitka_macos_permissions = self.get_value("nuitka", "macos.permissions")
+            if nuitka_macos_permissions:
+                self._permissions = nuitka_macos_permissions.split(",")
+            else:
+                self._find_and_set_permissions()
+
+    @property
+    def qt_plugins(self):
+        return self._qt_plugins
+
+    @qt_plugins.setter
+    def qt_plugins(self, qt_plugins):
+        self._qt_plugins = qt_plugins
+        self.set_value("qt", "plugins", ",".join(qt_plugins))
+
+    @property
+    def permissions(self):
+        return self._permissions
+
+    @permissions.setter
+    def permissions(self, permissions):
+        self._permissions = permissions
+        self.set_value("nuitka", "macos.permissions", ",".join(permissions))
+
+    def _find_dependent_qt_modules(self):
+        """
+        Given pysidedeploy_config.modules, find all the other dependent Qt modules.
+        """
+        all_modules = set(self.modules)
+
+        if not self.dependency_reader.lib_reader:
+            warnings.warn(f"[DEPLOY] Unable to find {self.dependency_reader.lib_reader_name}. This "
+                          "tool helps to find the Qt module dependencies of the application. "
+                          "Skipping checking for dependencies.", category=RuntimeWarning)
+            return
+
+        for module_name in self.modules:
+            self.dependency_reader.find_dependencies(module=module_name, used_modules=all_modules)
+
+        self.modules = list(all_modules)
+
+    def _find_and_set_permissions(self):
+        """
+        Finds and sets the usage description string required for each permission requested by the
+        macOS application.
+        """
+        permissions = []
+        perm_categories = find_permission_categories(project_dir=self.project_dir,
+                                                     extra_ignore_dirs=self.extra_ignore_dirs,
+                                                     project_data=self.project_data)
+
+        perm_categories_str = ",".join(perm_categories)
+        logging.info(f"[DEPLOY] Usage descriptions for the {perm_categories_str} will be added to "
+                     "the Info.plist file of the macOS application bundle")
+
+        # handling permissions
+        for perm_category in perm_categories:
+            if perm_category in PERMISSION_MAP:
+                permissions.append(PERMISSION_MAP[perm_category])
+
+        self.permissions = permissions
diff --git a/sources/pyside-tools/deploy_lib/default.spec b/sources/pyside-tools/deploy_lib/default.spec
new file mode 100644
index 000000000..0a729d585
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/default.spec
@@ -0,0 +1,97 @@
+[app]
+
+# Title of your application
+title = pyside_app_demo
+
+# Project Directory. The general assumption is that project_dir is the parent directory
+# of input_file
+project_dir =
+
+# Source file path
+input_file =
+
+# Directory where exec is stored
+exec_directory =
+
+# Path to .pyproject project file
+project_file =
+
+# Application icon
+icon =
+
+[python]
+
+# Python path
+python_path =
+
+# python packages to install
+# ordered-set: increase compile time performance of nuitka packaging
+# zstandard: provides final executable size optimization
+packages = Nuitka==2.1
+
+# buildozer: for deploying Android application
+android_packages = buildozer==1.5.0,cython==0.29.33
+
+[qt]
+
+# Comma separated path to QML files required
+# normally all the QML files required by the project are added automatically
+qml_files =
+
+# excluded qml plugin binaries
+excluded_qml_plugins =
+
+# Qt modules used. Comma separated
+modules =
+
+# Qt plugins used by the application
+plugins =
+
+[android]
+
+# path to PySide wheel
+wheel_pyside =
+
+# path to Shiboken wheel
+wheel_shiboken =
+
+# plugins to be copied to libs folder of the packaged application. Comma separated
+plugins =
+
+[nuitka]
+
+# usage description for permissions requested by the app as found in the Info.plist file
+# of the app bundle
+# eg: NSCameraUsageDescription:CameraAccess
+macos.permissions =
+
+# (str) specify any extra nuitka arguments
+# eg: extra_args = --show-modules --follow-stdlib
+extra_args = --quiet --noinclude-qt-translations
+
+[buildozer]
+
+# build mode
+# possible options: [release, debug]
+# release creates an aab, while debug creates an apk
+mode = debug
+
+# contrains path to PySide6 and shiboken6 recipe dir
+recipe_dir =
+
+# path to extra Qt Android jars to be loaded by the application
+jars_dir =
+
+# if empty uses default ndk path downloaded by buildozer
+ndk_path =
+
+# if empty uses default sdk path downloaded by buildozer
+sdk_path =
+
+# other libraries to be loaded. Comma separated.
+# loaded at app startup
+local_libs =
+
+# architecture of deployed platform
+# possible values: ["aarch64", "armv7a", "i686", "x86_64"]
+arch =
diff --git a/sources/pyside-tools/deploy_lib/dependency_util.py b/sources/pyside-tools/deploy_lib/dependency_util.py
new file mode 100644
index 000000000..2d5b188d3
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/dependency_util.py
@@ -0,0 +1,319 @@
+# 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 ast
+import re
+import os
+import site
+import json
+import warnings
+import logging
+import shutil
+import sys
+from pathlib import Path
+from typing import List, Set
+from functools import lru_cache
+
+from . import IMPORT_WARNING_PYSIDE, run_command
+
+
+@lru_cache(maxsize=None)
+def get_py_files(project_dir: Path, extra_ignore_dirs: List[Path] = None, project_data=None):
+    """Finds and returns all the Python files in the project
+    """
+    py_candidates = []
+    ignore_dirs = ["__pycache__", "env", "venv", "deployment"]
+
+    if project_data:
+        py_candidates = project_data.python_files
+        ui_candidates = project_data.ui_files
+        qrc_candidates = project_data.qrc_files
+
+        def add_uic_qrc_candidates(candidates, candidate_type):
+            possible_py_candidates = [(file.parent / f"{candidate_type}_{file.stem}.py")
+                                      for file in candidates
+                                      if (file.parent / f"{candidate_type}_{file.stem}.py").exists()
+                                      ]
+
+            if len(possible_py_candidates) != len(candidates):
+                warnings.warn(f"[DEPLOY] The number of {candidate_type} files and their "
+                              "corresponding Python files don't match.",
+                              category=RuntimeWarning)
+
+            py_candidates.extend(possible_py_candidates)
+
+        if ui_candidates:
+            add_uic_qrc_candidates(ui_candidates, "ui")
+
+        if qrc_candidates:
+            add_uic_qrc_candidates(qrc_candidates, "qrc")
+
+        return py_candidates
+
+    # incase there is not .pyproject file, search all python files in project_dir, except
+    # ignore_dirs
+    if extra_ignore_dirs:
+        ignore_dirs.extend(extra_ignore_dirs)
+
+    # find relevant .py files
+    _walk = os.walk(project_dir)
+    for root, dirs, files in _walk:
+        dirs[:] = [d for d in dirs if d not in ignore_dirs and not d.startswith(".")]
+        for py_file in files:
+            if py_file.endswith(".py"):
+                py_candidates.append(Path(root) / py_file)
+
+    return py_candidates
+
+
+@lru_cache(maxsize=None)
+def get_ast(py_file: Path):
+    """Given a Python file returns the abstract syntax tree
+    """
+    contents = py_file.read_text(encoding="utf-8")
+    try:
+        tree = ast.parse(contents)
+    except SyntaxError:
+        print(f"[DEPLOY] Unable to parse {py_file}")
+    return tree
+
+
+def find_permission_categories(project_dir: Path, extra_ignore_dirs: List[Path] = None,
+                               project_data=None):
+    """Given the project directory, finds all the permission categories required by the
+    project. eg: Camera, Bluetooth, Contacts etc.
+
+    Note: This function is only relevant for mac0S deployment.
+    """
+    all_perm_categories = set()
+    mod_pattern = re.compile("Q(?P<mod_name>.*)Permission")
+
+    def pyside_permission_imports(py_file: Path):
+        perm_categories = []
+        try:
+            tree = get_ast(py_file)
+            for node in ast.walk(tree):
+                if isinstance(node, ast.ImportFrom):
+                    main_mod_name = node.module
+                    if main_mod_name == "PySide6.QtCore":
+                        # considers 'from PySide6.QtCore import QtMicrophonePermission'
+                        for imported_module in node.names:
+                            full_mod_name = imported_module.name
+                            match = mod_pattern.search(full_mod_name)
+                            if match:
+                                mod_name = match.group("mod_name")
+                                perm_categories.append(mod_name)
+                        continue
+
+                if isinstance(node, ast.Import):
+                    for imported_module in node.names:
+                        full_mod_name = imported_module.name
+                        if full_mod_name == "PySide6":
+                            logging.warning(IMPORT_WARNING_PYSIDE.format(str(py_file)))
+        except Exception as e:
+            raise RuntimeError(f"[DEPLOY] Finding permission categories failed on file "
+                               f"{str(py_file)} with error {e}")
+
+        return set(perm_categories)
+
+    py_candidates = get_py_files(project_dir, extra_ignore_dirs, project_data)
+    for py_candidate in py_candidates:
+        all_perm_categories = all_perm_categories.union(pyside_permission_imports(py_candidate))
+
+    if not all_perm_categories:
+        ValueError("[DEPLOY] No permission categories were found for macOS app bundle creation.")
+
+    return all_perm_categories
+
+
+def find_pyside_modules(project_dir: Path, extra_ignore_dirs: List[Path] = None,
+                        project_data=None):
+    """
+    Searches all the python files in the project to find all the PySide modules used by
+    the application.
+    """
+    all_modules = set()
+    mod_pattern = re.compile("PySide6.Qt(?P<mod_name>.*)")
+
+    def pyside_module_imports(py_file: Path):
+        modules = []
+        try:
+            tree = get_ast(py_file)
+            for node in ast.walk(tree):
+                if isinstance(node, ast.ImportFrom):
+                    main_mod_name = node.module
+                    if main_mod_name.startswith("PySide6"):
+                        if main_mod_name == "PySide6":
+                            # considers 'from PySide6 import QtCore'
+                            for imported_module in node.names:
+                                full_mod_name = imported_module.name
+                                if full_mod_name.startswith("Qt"):
+                                    modules.append(full_mod_name[2:])
+                            continue
+
+                        # considers 'from PySide6.QtCore import Qt'
+                        match = mod_pattern.search(main_mod_name)
+                        if match:
+                            mod_name = match.group("mod_name")
+                            modules.append(mod_name)
+                        else:
+                            logging.warning((
+                                f"[DEPLOY] Unable to find module name from {ast.dump(node)}"))
+
+                if isinstance(node, ast.Import):
+                    for imported_module in node.names:
+                        full_mod_name = imported_module.name
+                        if full_mod_name == "PySide6":
+                            logging.warning(IMPORT_WARNING_PYSIDE.format(str(py_file)))
+        except Exception as e:
+            raise RuntimeError(f"[DEPLOY] Finding module import failed on file {str(py_file)} with "
+                               f"error {e}")
+
+        return set(modules)
+
+    py_candidates = get_py_files(project_dir, extra_ignore_dirs, project_data)
+    for py_candidate in py_candidates:
+        all_modules = all_modules.union(pyside_module_imports(py_candidate))
+
+    if not all_modules:
+        ValueError("[DEPLOY] No PySide6 modules were found")
+
+    return list(all_modules)
+
+
+class QtDependencyReader:
+    def __init__(self, dry_run: bool = False) -> None:
+        self.dry_run = dry_run
+        self.lib_reader_name = None
+        self.qt_module_path_pattern = None
+        self.lib_pattern = None
+        self.command = None
+        self.qt_libs_dir = None
+
+        if sys.platform == "linux":
+            self.lib_reader_name = "readelf"
+            self.qt_module_path_pattern = "libQt6{module}.so.6"
+            self.lib_pattern = re.compile("libQt6(?P<mod_name>.*).so.6")
+            self.command_args = "-d"
+        elif sys.platform == "darwin":
+            self.lib_reader_name = "dyld_info"
+            self.qt_module_path_pattern = "Qt{module}.framework/Versions/A/Qt{module}"
+            self.lib_pattern = re.compile("@rpath/Qt(?P<mod_name>.*).framework/Versions/A/")
+            self.command_args = "-dependents"
+        elif sys.platform == "win32":
+            self.lib_reader_name = "dumpbin"
+            self.qt_module_path_pattern = "Qt6{module}.dll"
+            self.lib_pattern = re.compile("Qt6(?P<mod_name>.*).dll")
+            self.command_args = "/dependents"
+        else:
+            print(f"[DEPLOY] Deployment on unsupported platfrom {sys.platform}")
+            sys.exit(1)
+
+        self.pyside_install_dir = None
+        self.qt_libs_dir = self.get_qt_libs_dir()
+        self._lib_reader = shutil.which(self.lib_reader_name)
+
+    def get_qt_libs_dir(self):
+        """
+        Finds the path to the Qt libs directory inside PySide6 package installation
+        """
+        for possible_site_package in site.getsitepackages():
+            if possible_site_package.endswith("site-packages"):
+                self.pyside_install_dir = Path(possible_site_package) / "PySide6"
+
+        if not self.pyside_install_dir:
+            print("Unable to find site-packages. Exiting ...")
+            sys.exit(-1)
+
+        if sys.platform == "win32":
+            return self.pyside_install_dir
+
+        return self.pyside_install_dir / "Qt" / "lib"  # for linux and macOS
+
+    @property
+    def lib_reader(self):
+        return self._lib_reader
+
+    def find_dependencies(self, module: str, used_modules: Set[str] = None):
+        """
+        Given a Qt module, find all the other Qt modules it is dependent on and add it to the
+        'used_modules' set
+        """
+        qt_module_path = self.qt_libs_dir / self.qt_module_path_pattern.format(module=module)
+        if not qt_module_path.exists():
+            warnings.warn(f"[DEPLOY] {qt_module_path.name} not found in {str(qt_module_path)}."
+                          "Skipping finding its dependencies.", category=RuntimeWarning)
+            return
+
+        lib_pattern = re.compile(self.lib_pattern)
+        command = [self.lib_reader, self.command_args, str(qt_module_path)]
+        # print the command if dry_run is True.
+        # Normally run_command is going to print the command in dry_run mode. But, this is a
+        # special case where we need to print the command as well as to run it.
+        if self.dry_run:
+            command_str = " ".join(command)
+            print(command_str + "\n")
+
+        # We need to run this even for dry run, to see the full Nuitka command being executed
+        _, output = run_command(command=command, dry_run=False, fetch_output=True)
+
+        dependent_modules = set()
+        for line in output.splitlines():
+            line = line.decode("utf-8").lstrip()
+            if sys.platform == "darwin":
+                if line.endswith(f"Qt{module} [arm64]:"):
+                    # macOS Qt frameworks bundles have both x86_64 and arm64 architectures
+                    # We only need to consider one as the dependencies are redundant
+                    break
+                elif line.endswith(f"Qt{module} [X86_64]:"):
+                    # this line needs to be skipped because it matches with the pattern
+                    # and is related to the module itself, not the dependencies of the module
+                    continue
+            elif sys.platform == "win32" and line.startswith("Summary"):
+                # the dependencies would be found before the `Summary` line
+                break
+            match = lib_pattern.search(line)
+            if match:
+                dep_module = match.group("mod_name")
+                dependent_modules.add(dep_module)
+                if dep_module not in used_modules:
+                    used_modules.add(dep_module)
+                    self.find_dependencies(module=dep_module, used_modules=used_modules)
+
+        if dependent_modules:
+            logging.info(f"[DEPLOY] Following dependencies found for {module}: {dependent_modules}")
+        else:
+            logging.info(f"[DEPLOY] No Qt dependencies found for {module}")
+
+    def find_plugin_dependencies(self, used_modules: List[str], python_exe: Path) -> List[str]:
+        """
+        Given the modules used by the application, returns all the required plugins
+        """
+        plugins = set()
+        pyside_wheels = ["PySide6_Essentials", "PySide6_Addons"]
+        # TODO from 3.12 use list(dist.name for dist in importlib.metadata.distributions())
+        _, installed_packages = run_command(command=[str(python_exe), "-m", "pip", "freeze"],
+                                            dry_run=False, fetch_output=True)
+        installed_packages = [p.decode().split('==')[0] for p in installed_packages.split()]
+        for pyside_wheel in pyside_wheels:
+            if pyside_wheel not in installed_packages:
+                # the wheel is not installed and hence no plugins are checked for its modules
+                logging.warning((f"[DEPLOY] The package {pyside_wheel} is not installed. "))
+                continue
+            pyside_mod_plugin_json_name = f"{pyside_wheel}.json"
+            pyside_mod_plugin_json_file = self.pyside_install_dir / pyside_mod_plugin_json_name
+            if not pyside_mod_plugin_json_file.exists():
+                warnings.warn(f"[DEPLOY] Unable to find {pyside_mod_plugin_json_file}.",
+                              category=RuntimeWarning)
+                continue
+
+            # convert the json to dict
+            pyside_mod_dict = {}
+            with open(pyside_mod_plugin_json_file) as pyside_json:
+                pyside_mod_dict = json.load(pyside_json)
+
+            # find all the plugins in the modules
+            for module in used_modules:
+                plugins.update(pyside_mod_dict.get(module, []))
+
+        return list(plugins)
diff --git a/sources/pyside-tools/deploy_lib/deploy_util.py b/sources/pyside-tools/deploy_lib/deploy_util.py
new file mode 100644
index 000000000..e8b05e990
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/deploy_util.py
@@ -0,0 +1,77 @@
+# 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 logging
+import shutil
+import sys
+from pathlib import Path
+
+from . import EXE_FORMAT
+from .config import Config
+
+
+def config_option_exists():
+    for argument in sys.argv:
+        if any(item in argument for item in ["--config-file", "-c"]):
+            return True
+
+    return False
+
+
+def cleanup(config: Config, is_android: bool = False):
+    """
+        Cleanup the generated build folders/files
+    """
+    if config.generated_files_path.exists():
+        shutil.rmtree(config.generated_files_path)
+        logging.info("[DEPLOY] Deployment directory purged")
+
+    if is_android:
+        buildozer_spec: Path = config.project_dir / "buildozer.spec"
+        if buildozer_spec.exists():
+            buildozer_spec.unlink()
+            logging.info(f"[DEPLOY] {str(buildozer_spec)} removed")
+
+        buildozer_build: Path = config.project_dir / ".buildozer"
+        if buildozer_build.exists():
+            shutil.rmtree(buildozer_build)
+            logging.info(f"[DEPLOY] {str(buildozer_build)} removed")
+
+
+def create_config_file(dry_run: bool = False, config_file: Path = None, main_file: Path = None):
+    """
+        Sets up a new pysidedeploy.spec or use an existing config file
+    """
+
+    if main_file:
+        if main_file.parent != Path.cwd():
+            config_file = main_file.parent / "pysidedeploy.spec"
+        else:
+            config_file = Path.cwd() / "pysidedeploy.spec"
+
+    logging.info(f"[DEPLOY] Creating config file {config_file}")
+    if not dry_run:
+        shutil.copy(Path(__file__).parent / "default.spec", config_file)
+
+    # the config parser needs a reference to parse. So, in the case of --dry-run
+    # use the default.spec file.
+    if dry_run:
+        config_file = Path(__file__).parent / "default.spec"
+
+    return config_file
+
+
+def finalize(config: Config):
+    """
+        Copy the executable into the final location
+        For Android deployment, this is done through buildozer
+    """
+    generated_exec_path = config.generated_files_path / (config.source_file.stem + EXE_FORMAT)
+    if generated_exec_path.exists() and config.exe_dir:
+        if sys.platform == "darwin":
+            shutil.copytree(generated_exec_path, config.exe_dir / (config.title + EXE_FORMAT),
+                            dirs_exist_ok=True)
+        else:
+            shutil.copy(generated_exec_path, config.exe_dir)
+        print("[DEPLOY] Executed file created in "
+              f"{str(config.exe_dir / (config.source_file.stem + EXE_FORMAT))}")
diff --git a/sources/pyside-tools/deploy_lib/nuitka_helper.py b/sources/pyside-tools/deploy_lib/nuitka_helper.py
new file mode 100644
index 000000000..ac9a83f3f
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/nuitka_helper.py
@@ -0,0 +1,118 @@
+# 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 logging
+import os
+import sys
+from pathlib import Path
+from typing import List
+
+from . import MAJOR_VERSION, run_command
+
+
+class Nuitka:
+    """
+    Wrapper class around the nuitka executable, enabling its usage through python code
+    """
+
+    def __init__(self, nuitka):
+        self.nuitka = nuitka
+        # plugins to ignore. The sensible plugins are include by default by Nuitka for PySide6
+        # application deployment
+        self.qt_plugins_to_ignore = ["imageformats",  # being Nuitka `sensible`` plugins
+                                     "iconengines",
+                                     "mediaservice",
+                                     "printsupport",
+                                     "platforms",
+                                     "platformthemes",
+                                     "styles",
+                                     "wayland-shell-integration",
+                                     "wayland-decoration-client",
+                                     "wayland-graphics-integration-client",
+                                     "egldeviceintegrations",
+                                     "xcbglintegrations",
+                                     "tls",  # end Nuitka `sensible` plugins
+                                     "generic"  # plugins that error with Nuitka
+                                     ]
+
+        # .webp are considered to be dlls by Nuitka instead of data files causing
+        # the packaging to fail
+        # https://github.com/Nuitka/Nuitka/issues/2854
+        # TODO: Remove .webp when the issue is fixed
+        self.files_to_ignore = [".cpp.o", ".qsb", ".webp"]
+
+    @staticmethod
+    def icon_option():
+        if sys.platform == "linux":
+            return "--linux-icon"
+        elif sys.platform == "win32":
+            return "--windows-icon-from-ico"
+        else:
+            return "--macos-app-icon"
+
+    def create_executable(self, source_file: Path, extra_args: str, qml_files: List[Path],
+                          qt_plugins: List[str], excluded_qml_plugins: List[str], icon: str,
+                          dry_run: bool, permissions: List[str]):
+        qt_plugins = [plugin for plugin in qt_plugins if plugin not in self.qt_plugins_to_ignore]
+        extra_args = extra_args.split()
+
+        if sys.platform == "darwin":
+            # create an app bundle
+            extra_args.extend(["--standalone", "--macos-create-app-bundle"])
+            permission_pattern = "--macos-app-protected-resource={permission}"
+            for permission in permissions:
+                extra_args.append(permission_pattern.format(permission=permission))
+        else:
+            extra_args.append("--onefile")
+
+        qml_args = []
+        if qml_files:
+            # This will generate options for each file using:
+            #     --include-data-files=ABSOLUTE_PATH_TO_FILE=RELATIVE_PATH_TO ROOT
+            # for each file. This will preserve the directory structure of QML resources.
+            qml_args.extend(
+                [f"--include-data-files={qml_file.resolve()}="
+                 f"./{qml_file.resolve().relative_to(source_file.parent)}"
+                 for qml_file in qml_files]
+            )
+            # add qml plugin. The `qml`` plugin name is not present in the module json files shipped
+            # with Qt and hence not in `qt_plugins``. However, Nuitka uses the 'qml' plugin name to
+            # include the necessary qml plugins. There we have to add it explicitly for a qml
+            # application
+            qt_plugins.append("qml")
+
+            if excluded_qml_plugins:
+                prefix = "lib" if sys.platform != "win32" else ""
+                for plugin in excluded_qml_plugins:
+                    dll_name = plugin.replace("Qt", f"Qt{MAJOR_VERSION}")
+                    qml_args.append(f"--noinclude-dlls={prefix}{dll_name}*")
+
+            # Exclude .qen json files from QtQuickEffectMaker
+            # These files are not relevant for PySide6 applications
+            qml_args.append("--noinclude-dlls=*/qml/QtQuickEffectMaker/*")
+
+        # Exclude files that cannot be processed by Nuitka
+        for file in self.files_to_ignore:
+            extra_args.append(f"--noinclude-dlls=*{file}")
+
+        output_dir = source_file.parent / "deployment"
+        if not dry_run:
+            output_dir.mkdir(parents=True, exist_ok=True)
+            logging.info("[DEPLOY] Running Nuitka")
+        command = self.nuitka + [
+            os.fspath(source_file),
+            "--follow-imports",
+            "--enable-plugin=pyside6",
+            f"--output-dir={output_dir}",
+        ]
+
+        command.extend(extra_args + qml_args)
+        command.append(f"{self.__class__.icon_option()}={icon}")
+        if qt_plugins:
+            # sort qt_plugins so that the result is definitive when testing
+            qt_plugins.sort()
+            qt_plugins_str = ",".join(qt_plugins)
+            command.append(f"--include-qt-plugins={qt_plugins_str}")
+
+        command_str, _ = run_command(command=command, dry_run=dry_run)
+        return command_str
diff --git a/sources/pyside-tools/deploy_lib/pyside_icon.icns b/sources/pyside-tools/deploy_lib/pyside_icon.icns
new file mode 100644
index 000000000..a6eb02bb0
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/pyside_icon.icns
diff --git a/sources/pyside-tools/deploy_lib/pyside_icon.ico b/sources/pyside-tools/deploy_lib/pyside_icon.ico
new file mode 100644
index 000000000..332a3a568
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/pyside_icon.ico
diff --git a/sources/pyside-tools/deploy/pyside_icon.jpg b/sources/pyside-tools/deploy_lib/pyside_icon.jpg
index 647c42c71..647c42c71 100644
--- a/sources/pyside-tools/deploy/pyside_icon.jpg
+++ b/sources/pyside-tools/deploy_lib/pyside_icon.jpg
diff --git a/sources/pyside-tools/deploy_lib/python_helper.py b/sources/pyside-tools/deploy_lib/python_helper.py
new file mode 100644
index 000000000..7cbf323ed
--- /dev/null
+++ b/sources/pyside-tools/deploy_lib/python_helper.py
@@ -0,0 +1,122 @@
+# 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 logging
+import os
+import sys
+
+from importlib import util
+from importlib.metadata import version
+from pathlib import Path
+
+from . import Config, run_command
+
+
+class PythonExecutable:
+    """
+    Wrapper class around Python executable
+    """
+
+    def __init__(self, python_path: Path = None, dry_run: bool = False, init: bool = False,
+                 force: bool = False):
+
+        self.dry_run = dry_run
+        self.init = init
+        if not python_path:
+            response = "yes"
+            # checking if inside virtual environment
+            if not self.is_venv() and not force and not self.dry_run and not self.init:
+                response = input(("You are not using a virtual environment. pyside6-deploy needs "
+                                  "to install a few Python packages for deployment to work "
+                                  "seamlessly. \n Proceed? [Y/n]"))
+
+            if response.lower() in ["no", "n"]:
+                print("[DEPLOY] Exiting ...")
+                sys.exit(0)
+
+            self.exe = Path(sys.executable)
+        else:
+            self.exe = python_path
+
+        logging.info(f"[DEPLOY] Using Python at {str(self.exe)}")
+
+    @property
+    def exe(self):
+        return Path(self._exe)
+
+    @exe.setter
+    def exe(self, exe):
+        self._exe = exe
+
+    @staticmethod
+    def is_venv():
+        venv = os.environ.get("VIRTUAL_ENV")
+        return True if venv else False
+
+    def is_pyenv_python(self):
+        pyenv_root = os.environ.get("PYENV_ROOT")
+
+        if pyenv_root:
+            resolved_exe = self.exe.resolve()
+            if str(resolved_exe).startswith(pyenv_root):
+                return True
+
+        return False
+
+    def install(self, packages: list = None):
+        _, installed_packages = run_command(command=[str(self.exe), "-m", "pip", "freeze"],
+                                            dry_run=False, fetch_output=True)
+        installed_packages = [p.decode().split('==')[0] for p in installed_packages.split()]
+        for package in packages:
+            package_info = package.split('==')
+            package_components_len = len(package_info)
+            package_name, package_version = None, None
+            if package_components_len == 1:
+                package_name = package_info[0]
+            elif package_components_len == 2:
+                package_name = package_info[0]
+                package_version = package_info[1]
+            else:
+                raise ValueError(f"{package} should be of the format 'package_name'=='version'")
+            if (package_name not in installed_packages) and (not self.is_installed(package_name)):
+                logging.info(f"[DEPLOY] Installing package: {package}")
+                run_command(
+                    command=[self.exe, "-m", "pip", "install", package],
+                    dry_run=self.dry_run,
+                )
+            elif package_version:
+                installed_version = version(package_name)
+                if package_version != installed_version:
+                    logging.info(f"[DEPLOY] Installing package: {package_name}"
+                                 f"version: {package_version}")
+                    run_command(
+                        command=[self.exe, "-m", "pip", "install", "--force", package],
+                        dry_run=self.dry_run,
+                    )
+                else:
+                    logging.info(f"[DEPLOY] package: {package_name}=={package_version}"
+                                 " already installed")
+            else:
+                logging.info(f"[DEPLOY] package: {package_name} already installed")
+
+    def is_installed(self, package):
+        return bool(util.find_spec(package))
+
+    def install_dependencies(self, config: Config, packages: str, is_android: bool = False):
+        """
+        Installs the python package dependencies for the target deployment platform
+        """
+        packages = config.get_value("python", packages).split(",")
+        if not self.init:
+            # install packages needed for deployment
+            logging.info("[DEPLOY] Installing dependencies")
+            self.install(packages=packages)
+            # nuitka requires patchelf to make patchelf rpath changes for some Qt files
+            if sys.platform.startswith("linux") and not is_android:
+                self.install(packages=["patchelf"])
+        elif is_android:
+            # install only buildozer
+            logging.info("[DEPLOY] Installing buildozer")
+            buildozer_package_with_version = ([package for package in packages
+                                               if package.startswith("buildozer")])
+            self.install(packages=list(buildozer_package_with_version))
diff --git a/sources/pyside-tools/metaobjectdump.py b/sources/pyside-tools/metaobjectdump.py
index 05a14fdd6..0970f9974 100644
--- a/sources/pyside-tools/metaobjectdump.py
+++ b/sources/pyside-tools/metaobjectdump.py
@@ -8,7 +8,7 @@ import sys
 import tokenize
 from argparse import ArgumentParser, RawTextHelpFormatter
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Set, Tuple, Union
 
 
 DESCRIPTION = """Parses Python source code to create QObject metatype
@@ -27,7 +27,19 @@ QML_IMPORT_MINOR_VERSION = "QML_IMPORT_MINOR_VERSION"
 QT_MODULES = "QT_MODULES"
 
 
+ITEM_MODELS = ["QAbstractListModel", "QAbstractProxyModel",
+               "QAbstractTableModel", "QConcatenateTablesProxyModel",
+               "QFileSystemModel", "QIdentityProxyModel", "QPdfBookmarkModel",
+               "QPdfSearchModel", "QSortFilterProxyModel", "QSqlQueryModel",
+               "QStandardItemModel", "QStringListModel", "QTransposeProxyModel",
+               "QWebEngineHistoryModel"]
+
+
+QOBJECT_DERIVED = ["QObject", "QQuickItem", "QQuickPaintedItem"] + ITEM_MODELS
+
+
 AstDecorator = Union[ast.Name, ast.Call]
+AstPySideTypeSpec = Union[ast.Name, ast.Constant]
 
 
 ClassList = List[dict]
@@ -35,9 +47,10 @@ ClassList = List[dict]
 
 PropertyEntry = Dict[str, Union[str, int, bool]]
 
-SignalArgument = Dict[str, str]
-SignalArguments = List[SignalArgument]
-Signal = Dict[str, Union[str, SignalArguments]]
+Argument = Dict[str, str]
+Arguments = List[Argument]
+Signal = Dict[str, Union[str, Arguments]]
+Slot = Dict[str, Union[str, Arguments]]
 
 
 def _decorator(name: str, value: str) -> Dict[str, str]:
@@ -84,12 +97,42 @@ def _parse_assignment(node: ast.Assign) -> Tuple[Optional[str], Optional[ast.AST
     return (None, None)
 
 
+def _parse_pyside_type(type_spec: AstPySideTypeSpec) -> str:
+    """Parse type specification of a Slot/Property decorator. Usually a type,
+       but can also be a string constant with a C++ type name."""
+    if isinstance(type_spec, ast.Constant):
+        return type_spec.value
+    return _python_to_cpp_type(_name(type_spec))
+
+
+def _parse_call_args(call: ast.Call):
+    """Parse arguments of a Signal call/Slot decorator (type list)."""
+    result: Arguments = []
+    for n, arg in enumerate(call.args):
+        par_name = f"a{n+1}"
+        par_type = _parse_pyside_type(arg)
+        result.append({"name": par_name, "type": par_type})
+    return result
+
+
+def _parse_slot(func_name: str, call: ast.Call) -> Slot:
+    """Parse a 'Slot' decorator."""
+    return_type = "void"
+    for kwarg in call.keywords:
+        if kwarg.arg == "result":
+            return_type = _python_to_cpp_type(_name(kwarg.value))
+            break
+    return {"access": "public", "name": func_name,
+            "arguments": _parse_call_args(call),
+            "returnType": return_type}
+
+
 class VisitorContext:
     """Stores a list of QObject-derived classes encountered in order to find
        out which classes inherit QObject."""
 
     def __init__(self):
-        self.qobject_derived = ["QObject", "QQuickItem", "QQuickPaintedItem"]
+        self.qobject_derived = QOBJECT_DERIVED
 
 
 class MetaObjectDumpVisitor(ast.NodeVisitor):
@@ -104,7 +147,7 @@ class MetaObjectDumpVisitor(ast.NodeVisitor):
         self._properties: List[PropertyEntry] = []
         self._signals: List[Signal] = []
         self._within_class: bool = False
-        self._qt_modules: List[str] = []
+        self._qt_modules: Set[str] = set()
         self._qml_import_name = ""
         self._qml_import_major_version = 0
         self._qml_import_minor_version = 0
@@ -119,7 +162,7 @@ class MetaObjectDumpVisitor(ast.NodeVisitor):
         return (self._qml_import_major_version, self._qml_import_minor_version)
 
     def qt_modules(self):
-        return self._qt_modules
+        return sorted(self._qt_modules)
 
     @staticmethod
     def create_ast(filename: Path) -> ast.Module:
@@ -146,6 +189,7 @@ class MetaObjectDumpVisitor(ast.NodeVisitor):
         """Visit a class definition"""
         self._properties = []
         self._signals = []
+        self._slots = []
         self._within_class = True
         qualified_name = node.name
         last_dot = qualified_name.rfind('.')
@@ -158,12 +202,14 @@ class MetaObjectDumpVisitor(ast.NodeVisitor):
         q_object = False
         bases = []
         for b in node.bases:
-            base_name = _name(b)
-            if base_name in self._context.qobject_derived:
-                q_object = True
-                self._context.qobject_derived.append(name)
-            base_dict = {"access": "public", "name": base_name}
-            bases.append(base_dict)
+            # PYSIDE-2202: catch weird constructs like "class C(type(Base)):"
+            if isinstance(b, ast.Name):
+                base_name = _name(b)
+                if base_name in self._context.qobject_derived:
+                    q_object = True
+                    self._context.qobject_derived.append(name)
+                base_dict = {"access": "public", "name": base_name}
+                bases.append(base_dict)
 
         data["object"] = q_object
         if bases:
@@ -188,6 +234,9 @@ class MetaObjectDumpVisitor(ast.NodeVisitor):
         if self._signals:
             data["signals"] = self._signals
 
+        if self._slots:
+            data["slots"] = self._slots
+
         self._json_class_list.append(data)
 
         self._within_class = False
@@ -224,7 +273,7 @@ class MetaObjectDumpVisitor(ast.NodeVisitor):
             elif name == "QmlNamedElement" and node.args:
                 name = node.args[0].value
                 class_decorators.append(_decorator("QML.Element", name))
-            else:
+            elif name.startswith('Q'):
                 print('Unknown decorator with parameters:', name,
                       file=sys.stderr)
             return
@@ -237,7 +286,7 @@ class MetaObjectDumpVisitor(ast.NodeVisitor):
                 class_decorators.append(_decorator("QML.Singleton", "true"))
             elif name == "QmlAnonymous":
                 class_decorators.append(_decorator("QML.Element", "anonymous"))
-            else:
+            elif name.startswith('Q'):
                 print('Unknown decorator:', name, file=sys.stderr)
             return
 
@@ -269,16 +318,16 @@ class MetaObjectDumpVisitor(ast.NodeVisitor):
             return
 
         if isinstance(node, ast.Call):
-            name = node.func.id
+            name = _name(node.func)
             if name == "Property":  # Property getter
-                if node.args:  # 1st is type
-                    type = _python_to_cpp_type(_name(node.args[0]))
+                if node.args:  # 1st is type/type string
+                    type = _parse_pyside_type(node.args[0])
                     prop = self._create_property_entry(func_name, type,
                                                        func_name)
                     _parse_property_kwargs(node.keywords, prop)
                     self._properties.append(prop)
             elif name == "Slot":
-                pass
+                self._slots.append(_parse_slot(func_name, node))
             else:
                 print('Unknown decorator with parameters:', name,
                       file=sys.stderr)
@@ -290,13 +339,8 @@ class MetaObjectDumpVisitor(ast.NodeVisitor):
             return
         func_name = _func_name(call)
         if func_name == "Signal" or func_name == "QtCore.Signal":
-            arguments: SignalArguments = []
-            for n, arg in enumerate(call.args):
-                par_name = f"a{n+1}"
-                par_type = _python_to_cpp_type(_name(arg))
-                arguments.append({"name": par_name, "type": par_type})
             signal: Signal = {"access": "public", "name": var_name,
-                              "arguments": arguments,
+                              "arguments": _parse_call_args(call),
                               "returnType": "void"}
             self._signals.append(signal)
         elif func_name == "Property" or func_name == "QtCore.Property":
@@ -313,16 +357,20 @@ class MetaObjectDumpVisitor(ast.NodeVisitor):
             self._properties.append(prop)
 
     def visit_Import(self, node):
-        if node.names:
-            self._handle_import(node.names[0].name)
+        for n in node.names:  # "import PySide6.QtWidgets"
+            self._handle_import(n.name)
 
     def visit_ImportFrom(self, node):
-        self._handle_import(node.module)
+        if "." in node.module:  # "from PySide6.QtWidgets import QWidget"
+            self._handle_import(node.module)
+        elif node.module == "PySide6":  # "from PySide6 import QtWidgets"
+            for n in node.names:
+                if n.name.startswith("Qt"):
+                    self._qt_modules.add(n.name)
 
     def _handle_import(self, mod: str):
-        if mod.startswith('PySide'):
-            dot = mod.index(".")
-            self._qt_modules.append(mod[dot + 1:])
+        if mod.startswith("PySide6."):
+            self._qt_modules.add(mod[8:])
 
 
 def create_arg_parser(desc: str) -> ArgumentParser:
diff --git a/sources/pyside-tools/project.py b/sources/pyside-tools/project.py
index 0daedbbb4..3706a2985 100644
--- a/sources/pyside-tools/project.py
+++ b/sources/pyside-tools/project.py
@@ -25,16 +25,19 @@ from typing import List, Tuple, Optional
 from pathlib import Path
 from argparse import ArgumentParser, RawTextHelpFormatter
 
-from project import (QmlProjectData, check_qml_decorators, QMLDIR_FILE,
-                     MOD_CMD, METATYPES_JSON_SUFFIX, requires_rebuild, run_command,
-                     remove_path, ProjectData, resolve_project_file, new_project,
-                     ProjectType)
+from project import (QmlProjectData, check_qml_decorators, is_python_file,
+                     QMLDIR_FILE, MOD_CMD, METATYPES_JSON_SUFFIX,
+                     SHADER_SUFFIXES, TRANSLATION_SUFFIX,
+                     requires_rebuild, run_command, remove_path,
+                     ProjectData, resolve_project_file, new_project,
+                     ProjectType, ClOptions)
 
 MODE_HELP = """build    Builds the project
 run        Builds the project and runs the first file")
 clean      Cleans the build artifacts")
 qmllint    Runs the qmllint tool
 deploy     Deploys the application
+lupdate    Updates translation (.ts) files
 new-ui     Creates a new QtWidgets project with a Qt Designer-based main window
 new-widget Creates a new QtWidgets project with a main window
 new-quick  Creates a new QtQuick project
@@ -42,20 +45,35 @@ new-quick  Creates a new QtQuick project
 
 UIC_CMD = "pyside6-uic"
 RCC_CMD = "pyside6-rcc"
+LRELEASE_CMD = "pyside6-lrelease"
+LUPDATE_CMD = "pyside6-lupdate"
 QMLTYPEREGISTRAR_CMD = "pyside6-qmltyperegistrar"
 QMLLINT_CMD = "pyside6-qmllint"
+QSB_CMD = "pyside6-qsb"
 DEPLOY_CMD = "pyside6-deploy"
 
 NEW_PROJECT_TYPES = {"new-quick": ProjectType.QUICK,
                      "new-ui": ProjectType.WIDGET_FORM,
                      "new-widget": ProjectType.WIDGET}
 
+
+def _sort_sources(files: List[Path]) -> List[Path]:
+    """Sort the sources for building, ensure .qrc is last since it might depend
+       on generated files."""
+
+    def key_func(p: Path):
+        return p.suffix if p.suffix != ".qrc" else ".zzzz"
+
+    return sorted(files, key=key_func)
+
+
 class Project:
     """
     Class to wrap the various operations on Project
     """
     def __init__(self, project_file: Path):
         self.project = ProjectData(project_file=project_file)
+        self.cl_options = ClOptions()
 
         # Files for QML modules using the QmlElement decorators
         self._qml_module_sources: List[Path] = []
@@ -68,10 +86,10 @@ class Project:
         """Run a pre-check on Python source files and find the ones with QML
         decorators (representing a QML module)."""
         # Quick check for any QML files (to avoid running moc for no reason).
-        if not opt_qml_module and not self.project.qml_files:
+        if not self.cl_options.qml_module and not self.project.qml_files:
             return
         for file in self.project.files:
-            if file.suffix == ".py":
+            if is_python_file(file):
                 has_class, data = check_qml_decorators(file)
                 if has_class:
                     self._qml_module_sources.append(file)
@@ -90,42 +108,54 @@ class Project:
         print(self._qml_module_dir)
         self._qml_dir_file = self._qml_module_dir / QMLDIR_FILE
 
-        if not opt_quiet:
+        if not self.cl_options.quiet:
             count = len(self._qml_module_sources)
             print(f"{self.project.project_file.name}, {count} QML file(s),"
                   f" {self._qml_project_data}")
 
-    def _get_artifact(self, file: Path) -> Tuple[Optional[Path], Optional[List[str]]]:
+    def _get_artifacts(self, file: Path) -> Tuple[List[Path], Optional[List[str]]]:
         """Return path and command for a file's artifact"""
         if file.suffix == ".ui":  # Qt form files
             py_file = f"{file.parent}/ui_{file.stem}.py"
-            return (Path(py_file), [UIC_CMD, os.fspath(file), "--rc-prefix", "-o", py_file])
+            return ([Path(py_file)], [UIC_CMD, os.fspath(file), "--rc-prefix", "-o", py_file])
         if file.suffix == ".qrc":  # Qt resources
             py_file = f"{file.parent}/rc_{file.stem}.py"
-            return (Path(py_file), [RCC_CMD, os.fspath(file), "-o", py_file])
+            return ([Path(py_file)], [RCC_CMD, os.fspath(file), "-o", py_file])
         # generate .qmltypes from sources with Qml decorators
         if file.suffix == ".py" and file in self._qml_module_sources:
             assert self._qml_module_dir
             qml_module_dir = os.fspath(self._qml_module_dir)
             json_file = f"{qml_module_dir}/{file.stem}{METATYPES_JSON_SUFFIX}"
-            return (Path(json_file), [MOD_CMD, "-o", json_file, os.fspath(file)])
+            return ([Path(json_file)], [MOD_CMD, "-o", json_file, os.fspath(file)])
         # Run qmltyperegistrar
         if file.name.endswith(METATYPES_JSON_SUFFIX):
             assert self._qml_module_dir
             stem = file.name[: len(file.name) - len(METATYPES_JSON_SUFFIX)]
             qmltypes_file = self._qml_module_dir / f"{stem}.qmltypes"
+            cpp_file = self._qml_module_dir / f"{stem}_qmltyperegistrations.cpp"
             cmd = [QMLTYPEREGISTRAR_CMD, "--generate-qmltypes",
-                   os.fspath(qmltypes_file), "-o", os.devnull, os.fspath(file)]
+                   os.fspath(qmltypes_file), "-o", os.fspath(cpp_file),
+                   os.fspath(file)]
             cmd.extend(self._qml_project_data.registrar_options())
-            return (qmltypes_file, cmd)
+            return ([qmltypes_file, cpp_file], cmd)
+
+        if file.name.endswith(TRANSLATION_SUFFIX):
+            qm_file = f"{file.parent}/{file.stem}.qm"
+            cmd = [LRELEASE_CMD, os.fspath(file), "-qm", qm_file]
+            return ([Path(qm_file)], cmd)
 
-        return (None, None)
+        if file.suffix in SHADER_SUFFIXES:
+            qsb_file = f"{file.parent}/{file.stem}.qsb"
+            cmd = [QSB_CMD, "-o", qsb_file, os.fspath(file)]
+            return ([Path(qsb_file)], cmd)
+
+        return ([], None)
 
     def _regenerate_qmldir(self):
         """Regenerate the 'qmldir' file."""
-        if opt_dry_run or not self._qml_dir_file:
+        if self.cl_options.dry_run or not self._qml_dir_file:
             return
-        if opt_force or requires_rebuild(self._qml_module_sources, self._qml_dir_file):
+        if self.cl_options.force or requires_rebuild(self._qml_module_sources, self._qml_dir_file):
             with self._qml_dir_file.open("w") as qf:
                 qf.write(f"module {self._qml_project_data.import_name}\n")
                 for f in self._qml_module_dir.glob("*.qmltypes"):
@@ -133,12 +163,11 @@ class Project:
 
     def _build_file(self, source: Path):
         """Build an artifact."""
-        artifact, command = self._get_artifact(source)
-        if not artifact:
-            return
-        if opt_force or requires_rebuild([source], artifact):
-            run_command(command, cwd=self.project.project_file.parent)
-        self._build_file(artifact)  # Recurse for QML (json->qmltypes)
+        artifacts, command = self._get_artifacts(source)
+        for artifact in artifacts:
+            if self.cl_options.force or requires_rebuild([source], artifact):
+                run_command(command, cwd=self.project.project_file.parent)
+            self._build_file(artifact)  # Recurse for QML (json->qmltypes)
 
     def build(self):
         """Build."""
@@ -146,7 +175,7 @@ class Project:
             Project(project_file=sub_project_file).build()
         if self._qml_module_dir:
             self._qml_module_dir.mkdir(exist_ok=True, parents=True)
-        for file in self.project.files:
+        for file in _sort_sources(self.project.files):
             self._build_file(file)
         self._regenerate_qmldir()
 
@@ -158,8 +187,8 @@ class Project:
 
     def _clean_file(self, source: Path):
         """Clean an artifact."""
-        artifact, command = self._get_artifact(source)
-        if artifact and artifact.is_file():
+        artifacts, command = self._get_artifacts(source)
+        for artifact in artifacts:
             remove_path(artifact)
             self._clean_file(artifact)  # Recurse for QML (json->qmltypes)
 
@@ -204,6 +233,24 @@ class Project:
         cmd.extend([str(self.project.main_file), "-f"])
         run_command(cmd, cwd=self.project.project_file.parent)
 
+    def lupdate(self):
+        for sub_project_file in self.project.sub_projects_files:
+            Project(project_file=sub_project_file).lupdate()
+
+        if not self.project.ts_files:
+            print(f"{self.project.project_file.name}: No .ts file found.",
+                  file=sys.stderr)
+            return
+
+        source_files = self.project.python_files + self.project.ui_files
+        cmd_prefix = [LUPDATE_CMD] + [p.name for p in source_files]
+        cmd_prefix.append("-ts")
+        for ts_file in self.project.ts_files:
+            if requires_rebuild(source_files, ts_file):
+                cmd = cmd_prefix
+                cmd.append(ts_file.name)
+                run_command(cmd, cwd=self.project.project_file.parent)
+
 
 if __name__ == "__main__":
     parser = ArgumentParser(description=__doc__, formatter_class=RawTextHelpFormatter)
@@ -212,17 +259,16 @@ if __name__ == "__main__":
     parser.add_argument("--force", "-f", action="store_true", help="Force rebuild")
     parser.add_argument("--qml-module", "-Q", action="store_true",
                         help="Perform check for QML module")
-    mode_choices = ["build", "run", "clean", "qmllint", "deploy"]
+    mode_choices = ["build", "run", "clean", "qmllint", "deploy", "lupdate"]
     mode_choices.extend(NEW_PROJECT_TYPES.keys())
     parser.add_argument("mode", choices=mode_choices, default="build",
                         type=str, help=MODE_HELP)
     parser.add_argument("file", help="Project file", nargs="?", type=str)
 
     options = parser.parse_args()
-    opt_quiet = options.quiet
-    opt_dry_run = options.dry_run
-    opt_force = options.force
-    opt_qml_module = options.qml_module
+    cl_options = ClOptions(dry_run=options.dry_run, quiet=options.quiet, force=options.force,
+                           qml_module=options.qml_module)
+
     mode = options.mode
 
     new_project_type = NEW_PROJECT_TYPES.get(mode)
@@ -247,6 +293,8 @@ if __name__ == "__main__":
         project.qmllint()
     elif mode == "deploy":
         project.deploy()
+    elif mode == "lupdate":
+        project.lupdate()
     else:
         print(f"Invalid mode {mode}", file=sys.stderr)
         sys.exit(1)
diff --git a/sources/pyside-tools/project/__init__.py b/sources/pyside-tools/project/__init__.py
index 60e3a5192..e57a9ff88 100644
--- a/sources/pyside-tools/project/__init__.py
+++ b/sources/pyside-tools/project/__init__.py
@@ -1,10 +1,7 @@
 # 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
 
-opt_quiet = False
-opt_dry_run = False
-opt_force = False
-opt_qml_module = False
+from dataclasses import dataclass
 
 QTPATHS_CMD = "qtpaths6"
 MOD_CMD = "pyside6-metaobjectdump"
@@ -17,9 +14,33 @@ QML_IMPORT_MAJOR_VERSION = "QML_IMPORT_MAJOR_VERSION"
 QML_IMPORT_MINOR_VERSION = "QML_IMPORT_MINOR_VERSION"
 QT_MODULES = "QT_MODULES"
 
-METATYPES_JSON_SUFFIX = "_metatypes.json"
+METATYPES_JSON_SUFFIX = "metatypes.json"
+TRANSLATION_SUFFIX = ".ts"
+SHADER_SUFFIXES = ".vert", ".frag"
+
+
+class Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super().__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+@dataclass(frozen=True)
+class ClOptions(metaclass=Singleton):
+    """
+    Dataclass to store the cl options that needs to be passed as arguments.
+    """
+    dry_run: bool
+    quiet: bool
+    force: bool
+    qml_module: bool
+
 
 from .utils import (run_command, requires_rebuild, remove_path, package_dir, qtpaths,
                     qt_metatype_json_dir, resolve_project_file)
-from .project_data import ProjectData, QmlProjectData, check_qml_decorators
+from .project_data import (is_python_file, ProjectData, QmlProjectData,
+                           check_qml_decorators)
 from .newproject import new_project, ProjectType
diff --git a/sources/pyside-tools/project/newproject.py b/sources/pyside-tools/project/newproject.py
index 5211c3979..c363a9fc0 100644
--- a/sources/pyside-tools/project/newproject.py
+++ b/sources/pyside-tools/project/newproject.py
@@ -145,7 +145,7 @@ def _qml_project() -> Project:
 
 
 def new_project(directory_s: str,
-                project_type: ProjectType=ProjectType.WIDGET_FORM) -> int:
+                project_type: ProjectType = ProjectType.WIDGET_FORM) -> int:
     directory = Path(directory_s)
     if directory.exists():
         print(f"{directory_s} already exists.", file=sys.stderr)
diff --git a/sources/pyside-tools/project/project_data.py b/sources/pyside-tools/project/project_data.py
index af94305a7..52e20be3f 100644
--- a/sources/pyside-tools/project/project_data.py
+++ b/sources/pyside-tools/project/project_data.py
@@ -7,9 +7,14 @@ import subprocess
 import sys
 from typing import List, Tuple
 from pathlib import Path
-from . import (METATYPES_JSON_SUFFIX, PROJECT_FILE_SUFFIX, qt_metatype_json_dir,
-               MOD_CMD, QML_IMPORT_MAJOR_VERSION, QML_IMPORT_MINOR_VERSION, QML_IMPORT_NAME,
-               QT_MODULES)
+from . import (METATYPES_JSON_SUFFIX, PROJECT_FILE_SUFFIX, TRANSLATION_SUFFIX,
+               qt_metatype_json_dir, MOD_CMD, QML_IMPORT_MAJOR_VERSION,
+               QML_IMPORT_MINOR_VERSION, QML_IMPORT_NAME, QT_MODULES)
+
+
+def is_python_file(file: Path) -> bool:
+    return (file.suffix == ".py"
+            or sys.platform == "win32" and file.suffix == ".pyw")
 
 
 class ProjectData:
@@ -25,6 +30,12 @@ class ProjectData:
         # Python files
         self.main_file: Path = None
         self._python_files: List[Path] = []
+        # ui files
+        self._ui_files: List[Path] = []
+        # qrc files
+        self._qrc_files: List[Path] = []
+        # ts files
+        self._ts_files: List[Path] = []
 
         with project_file.open("r") as pyf:
             pyproject = json.load(pyf)
@@ -36,10 +47,17 @@ class ProjectData:
                     self._files.append(file)
                     if file.suffix == ".qml":
                         self._qml_files.append(file)
-                    elif file.suffix == ".py":
-                        if file.name == "main.py":
+                    elif is_python_file(file):
+                        if file.stem == "main":
                             self.main_file = file
                         self._python_files.append(file)
+                    elif file.suffix == ".ui":
+                        self._ui_files.append(file)
+                    elif file.suffix == ".qrc":
+                        self._qrc_files.append(file)
+                    elif file.suffix == TRANSLATION_SUFFIX:
+                        self._ts_files.append(file)
+
         if not self.main_file:
             self._find_main_file()
 
@@ -64,10 +82,22 @@ class ProjectData:
         return self._python_files
 
     @property
+    def ui_files(self):
+        return self._ui_files
+
+    @property
+    def qrc_files(self):
+        return self._qrc_files
+
+    @property
     def qml_files(self):
         return self._qml_files
 
     @property
+    def ts_files(self):
+        return self._ts_files
+
+    @property
     def sub_projects_files(self):
         return self._sub_projects_files
 
@@ -85,7 +115,7 @@ class ProjectData:
 
         # __main__ not found
         print(
-            "Python file with main function not found. Add the file to" f" {project_file}",
+            "Python file with main function not found. Add the file to" f" {self.project_file}",
             file=sys.stderr,
         )
         sys.exit(1)
@@ -115,12 +145,16 @@ class QmlProjectData:
             meta_dir = qt_metatype_json_dir()
             for mod in self._qt_modules:
                 mod_id = mod[2:].lower()
-                pattern = f"qt6{mod_id}_*{METATYPES_JSON_SUFFIX}"
+                pattern = f"qt6{mod_id}_*"
+                if sys.platform != "win32":
+                    pattern += "_"  # qt6core_debug_metatypes.json (Linux)
+                pattern += METATYPES_JSON_SUFFIX
                 for f in meta_dir.glob(pattern):
                     foreign_files.append(os.fspath(f))
                     break
-                list = ",".join(foreign_files)
-                result.append(f"--foreign-types={list}")
+                if foreign_files:
+                    foreign_files_str = ",".join(foreign_files)
+                    result.append(f"--foreign-types={foreign_files_str}")
         return result
 
     @property
@@ -208,4 +242,3 @@ def check_qml_decorators(py_file: Path) -> Tuple[bool, QmlProjectData]:
         if v:
             qml_project_data.qt_modules = v
     return (has_class, qml_project_data)
-
diff --git a/sources/pyside-tools/project/utils.py b/sources/pyside-tools/project/utils.py
index 723b6211d..d2bff65af 100644
--- a/sources/pyside-tools/project/utils.py
+++ b/sources/pyside-tools/project/utils.py
@@ -6,14 +6,15 @@ import subprocess
 from pathlib import Path
 from typing import List, Dict, Optional
 
-from . import opt_dry_run, opt_quiet, QTPATHS_CMD, PROJECT_FILE_SUFFIX
+from . import QTPATHS_CMD, PROJECT_FILE_SUFFIX, ClOptions
 
 
 def run_command(command: List[str], cwd: str = None, ignore_fail: bool = False):
     """Run a command observing quiet/dry run"""
-    if not opt_quiet or opt_dry_run:
+    cloptions = ClOptions()
+    if not cloptions.quiet or cloptions.dry_run:
         print(" ".join(command))
-    if not opt_dry_run:
+    if not cloptions.dry_run:
         ex = subprocess.call(command, cwd=cwd)
         if ex != 0 and not ignore_fail:
             sys.exit(ex)
@@ -42,18 +43,19 @@ def _remove_path_recursion(path: Path):
 
 def remove_path(path: Path):
     """Remove path (file or directory) observing opt_dry_run."""
+    cloptions = ClOptions()
     if not path.exists():
         return
-    if not opt_quiet:
+    if not cloptions.quiet:
         print(f"Removing {path.name}...")
-    if opt_dry_run:
+    if cloptions.dry_run:
         return
     _remove_path_recursion(path)
 
 
 def package_dir() -> Path:
     """Return the PySide6 root."""
-    return Path(__file__).resolve().parents[1]
+    return Path(__file__).resolve().parents[2]
 
 
 _qtpaths_info: Dict[str, str] = {}
@@ -65,7 +67,7 @@ def qtpaths() -> Dict[str, str]:
     if not _qtpaths_info:
         output = subprocess.check_output([QTPATHS_CMD, "--query"])
         for line in output.decode("utf-8").split("\n"):
-            tokens = line.strip().split(":")
+            tokens = line.strip().split(":", maxsplit=1)  # "Path=C:\..."
             if len(tokens) == 2:
                 _qtpaths_info[tokens[0]] = tokens[1]
     return _qtpaths_info
@@ -81,7 +83,7 @@ def qt_metatype_json_dir() -> Path:
         qt_dir = package_dir()
         if sys.platform != "win32":
             qt_dir /= "Qt"
-        metatypes_dir = qt_dir / "lib" / "metatypes"
+        metatypes_dir = qt_dir / "metatypes"
         if metatypes_dir.is_dir():  # Fully installed case
             _qt_metatype_json_dir = metatypes_dir
         else:
@@ -89,7 +91,7 @@ def qt_metatype_json_dir() -> Path:
             print(
                 f"Falling back to {QTPATHS_CMD} to determine metatypes directory.", file=sys.stderr
             )
-            _qt_metatype_json_dir = Path(qtpaths()["QT_INSTALL_LIBS"]) / "metatypes"
+            _qt_metatype_json_dir = Path(qtpaths()["QT_INSTALL_ARCHDATA"]) / "metatypes"
     return _qt_metatype_json_dir
 
 
diff --git a/sources/pyside-tools/pyside_tool.py b/sources/pyside-tools/pyside_tool.py
index 8e4d1aac7..b369be8a2 100644
--- a/sources/pyside-tools/pyside_tool.py
+++ b/sources/pyside-tools/pyside_tool.py
@@ -2,15 +2,40 @@
 # 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
+import importlib
 import os
-from pathlib import Path
 import subprocess
+import sys
 import sysconfig
+from pathlib import Path
 
-from subprocess import Popen, PIPE
 import PySide6 as ref_mod
 
+VIRTUAL_ENV = "VIRTUAL_ENV"
+
+
+def is_pyenv_python():
+    pyenv_root = os.environ.get("PYENV_ROOT")
+
+    if pyenv_root:
+        resolved_exe = Path(sys.executable).resolve()
+        if str(resolved_exe).startswith(pyenv_root):
+            return True
+
+    return False
+
+
+def is_virtual_env():
+    return sys.prefix != sys.base_prefix
+
+
+def init_virtual_env():
+    """PYSIDE-2251: Enable running from a non-activated virtual environment
+       as is the case for Visual Studio Code by setting the VIRTUAL_ENV
+       variable which is used by the Qt Designer plugin."""
+    if is_virtual_env() and not os.environ.get(VIRTUAL_ENV):
+        os.environ[VIRTUAL_ENV] = sys.prefix
+
 
 def main():
     # This will take care of "pyside6-lupdate" listed as an entrypoint
@@ -31,14 +56,11 @@ def qt_tool_wrapper(qt_tool, args, libexec=False):
         exe = pyside_dir / qt_tool
 
     cmd = [os.fspath(exe)] + args
-    proc = Popen(cmd, stderr=PIPE)
-    out, err = proc.communicate()
-    if err:
-        msg = err.decode("utf-8")
+    returncode = subprocess.call(cmd)
+    if returncode != 0:
         command = ' '.join(cmd)
-        print(f"Error: {msg}\nwhile executing '{command}'")
-    sys.exit(proc.returncode)
-
+        print(f"'{command}' returned {returncode}", file=sys.stderr)
+    sys.exit(returncode)
 
 
 def pyside_script_wrapper(script_name):
@@ -69,7 +91,12 @@ def uic():
 
 
 def rcc():
-    qt_tool_wrapper("rcc", ['-g', 'python'] + sys.argv[1:], True)
+    args = []
+    user_args = sys.argv[1:]
+    if "--binary" not in user_args:
+        args.extend(['-g', 'python'])
+    args.extend(user_args)
+    qt_tool_wrapper("rcc", args, True)
 
 
 def qmltyperegistrar():
@@ -80,6 +107,10 @@ def qmlimportscanner():
     qt_tool_wrapper("qmlimportscanner", sys.argv[1:], True)
 
 
+def qmlcachegen():
+    qt_tool_wrapper("qmlcachegen", sys.argv[1:], True)
+
+
 def qmllint():
     qt_tool_wrapper("qmllint", sys.argv[1:])
 
@@ -96,19 +127,18 @@ def assistant():
     qt_tool_wrapper(ui_tool_binary("assistant"), sys.argv[1:])
 
 
-def _append_to_path_var(var, value):
+def _extend_path_var(var, value, prepend=False):
     env_value = os.environ.get(var)
     if env_value:
-        env_value = f'{env_value}{os.pathsep}{value}'
+        env_value = (f'{value}{os.pathsep}{env_value}'
+                     if prepend else f'{env_value}{os.pathsep}{value}')
     else:
         env_value = value
     os.environ[var] = env_value
 
 
 def designer():
-    # Add the examples to PYSIDE_DESIGNER_PLUGINS, as determined by starting from
-    # PySide6/scripts.
-    pyside_dir = Path(__file__).resolve().parents[1]
+    init_virtual_env()
 
     # https://www.python.org/dev/peps/pep-0384/#linkage :
     # "On Unix systems, the ABI is typically provided by the python executable
@@ -125,21 +155,28 @@ def designer():
         # Determine library name (examples/utils/pyside_config.py)
         version = f'{major_version}.{minor_version}'
         library_name = f'libpython{version}{sys.abiflags}.so'
+        if is_pyenv_python():
+            library_name = str(Path(sysconfig.get_config_var('LIBDIR')) / library_name)
         os.environ['LD_PRELOAD'] = library_name
     elif sys.platform == 'darwin':
         library_name = sysconfig.get_config_var("LDLIBRARY")
         framework_prefix = sysconfig.get_config_var("PYTHONFRAMEWORKPREFIX")
-        lib_path = os.fspath(Path(framework_prefix) / library_name)
+        lib_path = None
+        if framework_prefix:
+            lib_path = os.fspath(Path(framework_prefix) / library_name)
+        elif is_pyenv_python():
+            lib_path = str(Path(sysconfig.get_config_var('LIBDIR')) / library_name)
+        else:
+            # ideally this should never be reached because the system Python and Python installed
+            # from python.org are all framework builds
+            print("Unable to find Python library directory. Use a framework build of Python.",
+                  file=sys.stderr)
+            sys.exit(0)
         os.environ['DYLD_INSERT_LIBRARIES'] = lib_path
     elif sys.platform == 'win32':
         # Find Python DLLs from the base installation
-        if os.environ.get("VIRTUAL_ENV"):
-            _append_to_path_var("PATH", os.fspath(Path(sys._base_executable).parent))
-    # Add the Wiggly Widget example
-    wiggly_dir = os.fspath(pyside_dir / 'examples' / 'widgetbinding')
-    _append_to_path_var('PYSIDE_DESIGNER_PLUGINS', wiggly_dir)
-    taskmenu_dir = os.fspath(pyside_dir / 'examples' / 'designer' / 'taskmenuextension')
-    _append_to_path_var('PYSIDE_DESIGNER_PLUGINS', taskmenu_dir)
+        if is_virtual_env():
+            _extend_path_var("PATH", os.fspath(Path(sys._base_executable).parent), True)
 
     qt_tool_wrapper(ui_tool_binary("designer"), sys.argv[1:])
 
@@ -176,5 +213,31 @@ def deploy():
     pyside_script_wrapper("deploy.py")
 
 
+def android_deploy():
+    if not sys.platform == "linux":
+        print("pyside6-android-deploy only works from a Linux host")
+    else:
+        android_requirements_file = Path(__file__).parent / "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)
+        pyside_script_wrapper("android_deploy.py")
+
+
+def qsb():
+    qt_tool_wrapper("qsb", sys.argv[1:])
+
+
+def balsam():
+    qt_tool_wrapper("balsam", sys.argv[1:])
+
+
+def balsamui():
+    qt_tool_wrapper("balsamui", sys.argv[1:])
+
+
 if __name__ == "__main__":
     main()
diff --git a/sources/pyside-tools/qml.py b/sources/pyside-tools/qml.py
index 61e0e8ff9..5d029f93d 100644
--- a/sources/pyside-tools/qml.py
+++ b/sources/pyside-tools/qml.py
@@ -16,7 +16,7 @@ from typing import List, Set
 from PySide6.QtCore import QCoreApplication, Qt, QLibraryInfo, QUrl, SignalInstance
 from PySide6.QtGui import QGuiApplication, QSurfaceFormat
 from PySide6.QtQml import QQmlApplicationEngine, QQmlComponent
-from PySide6.QtQuick import QQuickView, QQuickWindow
+from PySide6.QtQuick import QQuickView, QQuickItem
 from PySide6.QtWidgets import QApplication
 
 
@@ -215,7 +215,7 @@ if __name__ == "__main__":
     if apptype == "core":
         component = QQmlComponent(engine, qml_file)
         obj = component.create()
-        filtered_attributes = {k: v for k, v in vars(obj).items() if type(v) != SignalInstance}
+        filtered_attributes = {k: v for k, v in vars(obj).items() if type(v) is not SignalInstance}
         logging.info("qml: component object attributes are")
         pprint(filtered_attributes)
         del engine
@@ -227,7 +227,7 @@ if __name__ == "__main__":
         sys.exit(-1)
 
     qquick_view = False
-    if type(rootObjects[0]) != QQuickWindow and qquick_present:
+    if isinstance(rootObjects[0], QQuickItem) and qquick_present:
         logging.info("qml: loading with QQuickView")
         viewer = QQuickView()
         viewer.setSource(qml_file)
diff --git a/sources/pyside-tools/qtpy2cpp_lib/tests/baseline/basic_test.py b/sources/pyside-tools/qtpy2cpp_lib/tests/baseline/basic_test.py
index 10dc73767..1466ac6b1 100644
--- a/sources/pyside-tools/qtpy2cpp_lib/tests/baseline/basic_test.py
+++ b/sources/pyside-tools/qtpy2cpp_lib/tests/baseline/basic_test.py
@@ -4,7 +4,7 @@
 
 import sys
 
-from PySide6.QtCore import qVersion, Qt
+from PySide6.QtCore import Qt
 from PySide6.QtGui import QColor, QPainter, QPaintEvent, QShortcut
 from PySide6.QtWidgets import QApplication, QWidget
 
diff --git a/sources/pyside-tools/qtpy2cpp_lib/tests/test_qtpy2cpp.py b/sources/pyside-tools/qtpy2cpp_lib/tests/test_qtpy2cpp.py
index f9f921705..894b2a958 100644
--- a/sources/pyside-tools/qtpy2cpp_lib/tests/test_qtpy2cpp.py
+++ b/sources/pyside-tools/qtpy2cpp_lib/tests/test_qtpy2cpp.py
@@ -14,7 +14,7 @@ def diff_code(actual_code, expected_file):
     with tempfile.NamedTemporaryFile(suffix=".cpp") as tf:
         tf.write(actual_code.encode('utf-8'))
         tf.flush()
-        diff_cmd = ["diff", "-u", expected_file,  tf.name]
+        diff_cmd = ["diff", "-u", expected_file, tf.name]
         subprocess.run(diff_cmd)
 
 
@@ -33,22 +33,22 @@ def run_converter(tool, file):
 def test_examples():
     dir = Path(__file__).resolve().parent
     tool = dir.parents[1] / "qtpy2cpp.py"
-    assert(tool.is_file)
+    assert tool.is_file
     for test_file in (dir / "baseline").glob("*.py"):
-        assert(test_file.is_file)
+        assert test_file.is_file
         expected_file = test_file.parent / (test_file.stem + ".cpp")
         if expected_file.is_file():
             actual_code = run_converter(tool, test_file)
-            assert(actual_code)
+            assert actual_code
             expected_code = expected_file.read_text()
             # Strip the license
             code_start = expected_code.find("// Converted from")
-            assert(code_start != -1)
+            assert code_start != -1
             expected_code = expected_code[code_start:]
 
             if actual_code != expected_code:
                 diff_code(actual_code, expected_file)
-            assert(actual_code == expected_code)
+            assert actual_code == expected_code
         else:
             print(f"Warning, {test_file} is missing a .cpp file.",
                   file=sys.stderr)
diff --git a/sources/pyside-tools/qtpy2cpp_lib/visitor.py b/sources/pyside-tools/qtpy2cpp_lib/visitor.py
index 1e8b5dc84..2056951ae 100644
--- a/sources/pyside-tools/qtpy2cpp_lib/visitor.py
+++ b/sources/pyside-tools/qtpy2cpp_lib/visitor.py
@@ -10,8 +10,7 @@ import warnings
 
 from .formatter import (CppFormatter, format_for_loop, format_literal,
                         format_name_constant,
-                        format_reference, format_start_function_call,
-                        write_import, write_import_from)
+                        format_reference, write_import, write_import_from)
 from .nodedump import debug_format_node
 from .qt import ClassFlag, qt_class_flags
 
diff --git a/sources/pyside-tools/requirements-android.txt b/sources/pyside-tools/requirements-android.txt
new file mode 100644
index 000000000..1169fd663
--- /dev/null
+++ b/sources/pyside-tools/requirements-android.txt
@@ -0,0 +1,2 @@
+jinja2
+pkginfo
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 7dd242828..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)
@@ -16,7 +27,7 @@ endif()
 
 if(Qt${QT_MAJOR_VERSION}UiTools_FOUND)
     add_subdirectory(plugins/uitools)
-    find_package(Qt${QT_MAJOR_VERSION}Designer)
+    find_package(Qt6 COMPONENTS Designer)
     # PYSIDE-535: Enable when PyPy supports embedding
     if (Qt${QT_MAJOR_VERSION}Designer_FOUND AND NOT PYPY_VERSION)
         add_subdirectory(plugins/designer)
@@ -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/FindQt5Extra.cmake b/sources/pyside6/cmake/Macros/FindQt5Extra.cmake
deleted file mode 100644
index 71846e48a..000000000
--- a/sources/pyside6/cmake/Macros/FindQt5Extra.cmake
+++ /dev/null
@@ -1,25 +0,0 @@
-#
-# Try to find QtMultimedia
-# TODO: Remove this hack when cmake support QtMultimedia module
-# CT: maybe we can remove this.
-# For now, I just use the mapping to Qt5
-
-find_package(Qt${QT_MAJOR_VERSION}Multimedia)
-
-if (NOT Qt${QT_MAJOR_VERSION}Multimedia_FOUND)
-    find_path(QT_QTMULTIMEDIA_INCLUDE_DIR QtMultimedia
-            PATHS ${QT_HEADERS_DIR}/QtMultimedia
-                ${QT_LIBRARY_DIR}/QtMultimedia.framework/Headers
-            NO_DEFAULT_PATH)
-    find_library(QT_QTMULTIMEDIA_LIBRARY QtMultimedia PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
-    if (QT_QTMULTIMEDIA_INCLUDE_DIR AND QT_QTMULTIMEDIA_LIBRARY)
-        set(QT_QTMULTIMEDIA_FOUND ON)
-    else()
-        #Replace this on documentation
-        set(if_QtMultimedia "<!--")
-        set(end_QtMultimedia "-->")
-    endif()
-endif ()
-
-# Maemo is no longer supported
-# QtDeclarative is no longer supported
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 43d042aef..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'):
@@ -90,7 +97,7 @@ if(QFP_QT_HOST_PATH)
         endif()
     endif()
 endif()
-find_package(Qt${QT_MAJOR_VERSION} 6.0 REQUIRED COMPONENTS Core)
+find_package(Qt6 REQUIRED COMPONENTS Core)
 
 add_definitions(${Qt${QT_MAJOR_VERSION}Core_DEFINITIONS})
 
@@ -177,7 +184,7 @@ foreach(m ${DISABLED_MODULES})
 endforeach()
 
 # Whether to add libpysideqml
-find_package(Qt${QT_MAJOR_VERSION}Qml)
+find_package(Qt6 COMPONENTS Qml)
 
 string(REGEX MATCHALL "[0-9]+" qt_version_helper "${Qt${QT_MAJOR_VERSION}Core_VERSION}")
 
@@ -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.
@@ -227,5 +239,5 @@ if(SANITIZE_ADDRESS AND NOT MSVC)
     setup_sanitize_address()
 endif()
 
-find_package(Qt${QT_MAJOR_VERSION}Designer)
+find_package(Qt6 COMPONENTS Designer)
 
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 cf55ae7cf..cfd465267 100644
--- a/sources/pyside6/libpyside/feature_select.cpp
+++ b/sources/pyside6/libpyside/feature_select.cpp
@@ -89,18 +89,14 @@ 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;
 
-static PyObject *_fast_id_array[1 + 256] = {};
-// this will point to element 1 to allow indexing from -1
-static PyObject **fast_id_array;
-
 // Create a derived dict class
 static PyTypeObject *
 createDerivedDictType()
@@ -111,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
 
@@ -133,43 +129,30 @@ 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);
-}
-
-static inline void setSelectId(PyObject *dict, PyObject *select_id)
-{
-    PyObject_SetAttr(dict, PyName::select_id(), select_id);
-}
-
-static inline PyObject *getSelectId(PyObject *dict)
-{
-    auto select_id = PyObject_GetAttr(dict, PyName::select_id());
-    return select_id;
-}
-
-static inline void setCurrentSelectId(PyTypeObject *type, PyObject *select_id)
-{
-    SbkObjectType_SetReserved(type, PyLong_AsSsize_t(select_id));    // int/long cheating
+    PyObject_SetAttr(dict, PySideName::dict_ring(), next_dict);
 }
 
-static inline void setCurrentSelectId(PyTypeObject *type, int id)
+static inline void setSelectId(PyObject *dict, int select_id)
 {
-    SbkObjectType_SetReserved(type, id);
+    PyObject_SetAttr(dict, PySideName::select_id(), PyLong_FromLong(select_id));
 }
 
-static inline PyObject *getCurrentSelectId(PyTypeObject *type)
+static inline int getSelectId(PyObject *dict)
 {
-    int id = SbkObjectType_GetReserved(type);
-    // This can be too early.
-    if (id < 0)
-        id = 0;
-    return fast_id_array[id];
+    auto *py_select_id = PyObject_GetAttr(dict, PyName::select_id());
+    if (py_select_id == nullptr) {
+        PyErr_Clear();
+        return 0;
+    }
+    int ret = PyLong_AsLong(py_select_id);
+    Py_DECREF(py_select_id);
+    return ret;
 }
 
 static bool replaceClassDict(PyTypeObject *type)
@@ -179,33 +162,32 @@ static bool replaceClassDict(PyTypeObject *type)
      * This is mandatory for all type dicts when they are touched.
      */
     ensureNewDictType();
-    PyObject *dict = type->tp_dict;
-    auto ob_ndt = reinterpret_cast<PyObject *>(new_dict_type);
-    PyObject *new_dict = PyObject_CallObject(ob_ndt, nullptr);
+    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)
         return false;
     // Insert the default id. Cannot fail for small numbers.
-    AutoDecRef select_id(PyLong_FromLong(0));
-    setSelectId(new_dict, select_id);
+    setSelectId(new_dict, 0);
     // 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;
-    setCurrentSelectId(type, select_id.object());
+    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;
 }
 
-static bool addNewDict(PyTypeObject *type, PyObject *select_id)
+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;
-    auto ob_ndt = reinterpret_cast<PyObject *>(new_dict_type);
-    auto new_dict = PyObject_CallObject(ob_ndt, nullptr);
+    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)
         return false;
     setSelectId(new_dict, select_id);
@@ -213,35 +195,35 @@ static bool addNewDict(PyTypeObject *type, PyObject *select_id)
     auto next_dict = nextInCircle(dict);
     setNextDict(dict, new_dict);
     setNextDict(new_dict, next_dict);
-    type->tp_dict = new_dict;
-    setCurrentSelectId(type, select_id);
+    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;
 }
 
-static bool moveToFeatureSet(PyTypeObject *type, PyObject *select_id)
+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;
-    auto dict = initial_dict;
+    AutoDecRef tpDict(PepType_GetDict(type));
+    auto *initial_dict = tpDict.object();
+    auto *dict = initial_dict;
     do {
-        dict = nextInCircle(dict);
-        AutoDecRef current_id(getSelectId(dict));
+        int current_id = getSelectId(dict);
         // This works because small numbers are singleton objects.
         if (current_id == select_id) {
-            type->tp_dict = dict;
-            setCurrentSelectId(type, select_id);
+            PepType_SetDict(type, dict);
             return true;
         }
+        dict = nextInCircle(dict);
     } while (dict != initial_dict);
-    type->tp_dict = initial_dict;
-    setCurrentSelectId(type, getSelectId(initial_dict));
+    PepType_SetDict(type, initial_dict);
     return false;
 }
 
-static bool createNewFeatureSet(PyTypeObject *type, PyObject *select_id)
+static bool createNewFeatureSet(PyTypeObject *type, int select_id)
 {
     /*
      * Create a new feature set.
@@ -251,37 +233,29 @@ static bool createNewFeatureSet(PyTypeObject *type, PyObject *select_id)
      * content in `prev_dict`. It is responsible of filling `type->tp_dict`
      * with modified content.
      */
-    static auto small_1 = PyLong_FromLong(255);
-    Q_UNUSED(small_1);
-    static auto small_2 = PyLong_FromLong(255);
-    Q_UNUSED(small_2);
-    // make sure that small integers are cached
-    assert(small_1 != nullptr && small_1 == small_2);
-
-    static auto zero = fast_id_array[0];
-    bool ok = moveToFeatureSet(type, zero);
+
+    bool ok = moveToFeatureSet(type, 0);
     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;
-    auto id = PyLong_AsSsize_t(select_id);   // int/long cheating
+    int id = select_id;
     if (id == -1)
         return false;
-    setCurrentSelectId(type, id);
     FeatureProc *proc = featurePointer;
     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;
             }
@@ -290,30 +264,59 @@ static bool createNewFeatureSet(PyTypeObject *type, PyObject *select_id)
     return true;
 }
 
-static bool SelectFeatureSetSubtype(PyTypeObject *type, PyObject *select_id)
+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)) {
             Py_FatalError("failed to replace class dict!");
-            return false;
+            return;
         }
     }
     if (!moveToFeatureSet(type, select_id)) {
         if (!createNewFeatureSet(type, select_id)) {
             Py_FatalError("failed to create a new feature set!");
-            return false;
+            return;
         }
     }
-    return true;
+ }
+
+static PyObject *cached_globals{};
+static int last_select_id{};
+
+static inline int getFeatureSelectId()
+{
+    static auto *undef = PyLong_FromLong(-1);
+    static auto *feature_dict = GetFeatureDict();
+    // these things are all borrowed
+    auto *globals = PyEval_GetGlobals();
+    if (globals == nullptr
+        || globals == cached_globals)
+        return last_select_id;
+
+    auto *modname = PyDict_GetItem(globals, PyMagicName::name());
+    if (modname == nullptr)
+        return last_select_id;
+
+    auto *py_select_id = PyDict_GetItem(feature_dict, modname);
+    if (py_select_id == nullptr
+        || !PyLong_Check(py_select_id)
+        || py_select_id == undef)
+        return last_select_id;
+
+    cached_globals = globals;
+    last_select_id = PyLong_AsLong(py_select_id) & 0xff;
+    return last_select_id;
 }
 
-static inline PyObject *SelectFeatureSet(PyTypeObject *type)
+static inline void SelectFeatureSet(PyTypeObject *type)
 {
     /*
      * This is the main function of the module.
@@ -323,33 +326,35 @@ static inline PyObject *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))
-            return nullptr;
-    }
-    PyObject *select_id = getFeatureSelectId();         // borrowed
-    PyObject *current_id = getCurrentSelectId(type);    // borrowed
-    static PyObject *undef = fast_id_array[-1];
-
-    // PYSIDE-1019: During import PepType_SOTP is still zero.
-    if (current_id == undef)
-        current_id = select_id = fast_id_array[0];
-
-    if (select_id != current_id) {
-        PyObject *mro = type->tp_mro;
-        Py_ssize_t idx, n = PyTuple_GET_SIZE(mro);
-        // We leave 'Shiboken.Object' and 'object' alone, therefore "n - 2".
-        for (idx = 0; idx < n - 2; idx++) {
-            auto *sub_type = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
-            // When any subtype is already resolved (false), we can stop.
-            if (!SelectFeatureSetSubtype(sub_type, select_id))
-                break;
+        if (!replaceClassDict(type)) {
+            Py_FatalError("failed to replace class dict!");
+            return;
         }
-        // PYSIDE-1436: Clear all caches for the type and subtypes.
-        PyType_Modified(type);
     }
-    return type->tp_dict;
+
+    int select_id = getFeatureSelectId();
+    static int last_select_id{};
+    static PyTypeObject *last_type{};
+
+    // PYSIDE-2029: Implement a very simple but effective cache that cannot fail.
+    if (type == last_type && select_id == last_select_id)
+        return;
+    last_type = type;
+    last_select_id = select_id;
+
+    auto *mro = type->tp_mro;
+    Py_ssize_t idx, n = PyTuple_GET_SIZE(mro);
+    // We leave 'Shiboken.Object' and 'object' alone, therefore "n - 2".
+    for (idx = 0; idx < n - 2; idx++) {
+        auto *sub_type = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        SelectFeatureSetSubtype(sub_type, select_id);
+    }
+    // PYSIDE-1436: Clear all caches for the type and subtypes.
+    PyType_Modified(type);
 }
 
 // For cppgenerator:
@@ -357,15 +362,14 @@ void Select(PyObject *obj)
 {
     if (featurePointer == nullptr)
         return;
-    auto type = Py_TYPE(obj);
-    type->tp_dict = SelectFeatureSet(type);
+    auto *type = Py_TYPE(obj);
+    SelectFeatureSet(type);
 }
 
-PyObject *Select(PyTypeObject *type)
+void Select(PyTypeObject *type)
 {
     if (featurePointer != nullptr)
-        type->tp_dict = SelectFeatureSet(type);
-    return type->tp_dict;
+        SelectFeatureSet(type);
 }
 
 static bool feature_01_addLowerNames(PyTypeObject *type, PyObject *prev_dict, int id);
@@ -389,30 +393,27 @@ static FeatureProc featureProcArray[] = {
     nullptr
 };
 
-void finalize()
-{
-    for (int idx = -1; idx < 256; ++idx)
-        Py_DECREF(fast_id_array[idx]);
-}
-
 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) {
-        fast_id_array = &_fast_id_array[1];
-        for (int idx = -1; idx < 256; ++idx)
-            fast_id_array[idx] = PyLong_FromLong(idx);
         featurePointer = featureProcArray;
         initSelectableFeature(SelectFeatureSet);
-        registerCleanupFunction(finalize);
+        setSelectableFeatureCallback(featureEnableCallback);
         patch_property_impl();
         is_initialized = true;
     }
+    last_select_id = 0;
     // Reset the cache. This is called at any "from __feature__ import".
-    initFeatureShibokenPart();
+    cached_globals = nullptr;
 }
 
 void Enable(bool enable)
@@ -442,7 +443,7 @@ static PyObject *methodWithNewName(PyTypeObject *type,
     /*
      * Create a method with a lower case name.
      */
-    auto obtype = reinterpret_cast<PyObject *>(type);
+    auto *obtype = reinterpret_cast<PyObject *>(type);
     int len = strlen(new_name);
     auto name = new char[len + 1];
     strcpy(name, new_name);
@@ -467,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.
@@ -514,20 +516,20 @@ 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)
 {
     AutoDecRef func_ob(PyObject_GetAttr(sm, PyMagicName::func()));
     if (func_ob.isNull())
         return nullptr;
-    auto func = reinterpret_cast<PyCFunctionObject *>(func_ob.object());
-    auto new_func = new PyMethodDef;
+    auto *func = reinterpret_cast<PyCFunctionObject *>(func_ob.object());
+    auto *new_func = new PyMethodDef;
     new_func->ml_name = func->m_ml->ml_name;
     new_func->ml_meth = func->m_ml->ml_meth;
     new_func->ml_flags = (func->m_ml->ml_flags & ~METH_STATIC) | METH_CLASS;
@@ -541,14 +543,14 @@ static PyObject *createProperty(PyTypeObject *type, PyObject *getter, PyObject *
     assert(getter != nullptr);
     if (setter == nullptr)
         setter = Py_None;
-    auto ptype = &PyProperty_Type;
+    auto *ptype = &PyProperty_Type;
     if (Py_TYPE(getter) == PepStaticMethod_TypePtr) {
         ptype = PyClassProperty_TypeF();
         getter = modifyStaticToClassMethod(type, getter);
         if (setter != Py_None)
             setter = modifyStaticToClassMethod(type, setter);
     }
-    auto obtype = reinterpret_cast<PyObject *>(ptype);
+    auto *obtype = reinterpret_cast<PyObject *>(ptype);
     PyObject *prop = PyObject_CallFunctionObjArgs(obtype, getter, setter, nullptr);
     return prop;
 }
@@ -598,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;
@@ -624,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)
@@ -643,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)
@@ -717,7 +720,7 @@ static bool feature_02_true_property(PyTypeObject *type, PyObject *prev_dict, in
 
 static PyObject *property_doc_get(PyObject *self, void *)
 {
-    auto po = reinterpret_cast<propertyobject *>(self);
+    auto *po = reinterpret_cast<propertyobject *>(self);
 
     if (po->prop_doc != nullptr && po->prop_doc != Py_None) {
         Py_INCREF(po->prop_doc);
@@ -725,7 +728,7 @@ static PyObject *property_doc_get(PyObject *self, void *)
     }
     if (po->prop_get) {
         // PYSIDE-1019: Fetch the default `__doc__` from fget. We do it late.
-        auto txt = PyObject_GetAttr(po->prop_get, PyMagicName::doc());
+        auto *txt = PyObject_GetAttr(po->prop_get, PyMagicName::doc());
         if (txt != nullptr) {
             Py_INCREF(txt);
             po->prop_doc = txt;
@@ -739,7 +742,7 @@ static PyObject *property_doc_get(PyObject *self, void *)
 
 static int property_doc_set(PyObject *self, PyObject *value, void *)
 {
-    auto po = reinterpret_cast<propertyobject *>(self);
+    auto *po = reinterpret_cast<propertyobject *>(self);
 
     Py_INCREF(value);
     po->prop_doc = value;
@@ -756,12 +759,12 @@ 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;
+    auto *type = &PyProperty_Type;
+    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;
 }
@@ -776,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) \
@@ -791,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 f7eed358b..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 PyObject *Select(PyTypeObject *type);
+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 672f990bb..9e12e3cd7 100644
--- a/sources/pyside6/libpyside/pyside.cpp
+++ b/sources/pyside6/libpyside/pyside.cpp
@@ -31,21 +31,29 @@
 #include <sbkconverter.h>
 #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;
 
@@ -56,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
 {
 
@@ -197,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;
@@ -232,7 +256,7 @@ static bool _setProperty(PyObject *qObj, PyObject *name, PyObject *value, bool *
 
     QByteArray propName(Shiboken::String::toCString(name));
     auto type = Py_TYPE(qObj);
-    int flags = SbkObjectType_GetReserved(type);
+    int flags = currentSelectId(type);
     int prop_flag = flags & 0x02;
     auto found = false;
     QByteArray getterName{}, setterName{};
@@ -272,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
@@ -296,16 +320,32 @@ 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;
     Py_ssize_t pos = 0;
-    int flags = SbkObjectType_GetReserved(Py_TYPE(qObj));
+    int flags = currentSelectId(Py_TYPE(qObj));
     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.
@@ -314,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;
                 }
             }
@@ -328,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());
@@ -418,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));
 }
 
@@ -444,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);
@@ -459,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.
@@ -489,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;
@@ -503,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 = SbkObjectType_GetReserved(Py_TYPE(self));
+        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
@@ -589,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);
@@ -609,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.
@@ -616,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;
@@ -655,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));
@@ -665,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;
 }
@@ -731,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[] = {
@@ -769,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)
@@ -783,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;
     }
@@ -829,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();
@@ -917,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..ed0cc5d0a 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,29 @@ 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.
+        PyObject *exc{}, *inst{}, *tb{};
+        PyErr_Fetch(&exc, &inst, &tb);
+        PyErr_WarnFormat(PyExc_RuntimeWarning, 0, "Failed to disconnect (%s) from signal \"%s\".",
+                         Py_TYPE(aSlot)->tp_name, signature.constData());
+        PyErr_Restore(exc, inst, tb);
+    } 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 +708,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 +724,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 +751,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 +797,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 +820,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 +834,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 +849,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 +911,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 +920,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 +953,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 +971,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 +1012,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 +1054,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 +1082,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 +1098,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 +1111,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 +1125,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 +1179,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 +1246,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 +1254,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 +1271,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 +1310,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 +1332,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 50074be51..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
@@ -7,18 +10,18 @@ set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 set(CMAKE_AUTOMOC ON)
 
-find_package(Qt6 COMPONENTS Core)
-find_package(Qt6 COMPONENTS Gui)
-find_package(Qt6 COMPONENTS Widgets)
-find_package(Qt6 COMPONENTS UiPlugin)
+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()
@@ -53,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 ee56cfa2c..06d0ae900 100644
--- a/sources/pyside6/plugins/uitools/CMakeLists.txt
+++ b/sources/pyside6/plugins/uitools/CMakeLists.txt
@@ -1,17 +1,17 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(plugins)
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 set(CMAKE_AUTOMOC ON)
 
-find_package(Qt6 COMPONENTS Core)
-find_package(Qt6 COMPONENTS Gui)
-find_package(Qt6 COMPONENTS Widgets)
-find_package(Qt6 COMPONENTS UiPlugin)
+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 d0932509e..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)
 
@@ -14,15 +17,18 @@ set(CMAKE_AUTOMOC ON)
 add_definitions(-DQT_SHARED)
 add_definitions(-DRXX_ALLOCATOR_INIT_0)
 
-find_package(Qt${QT_MAJOR_VERSION}Widgets)
+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.
@@ -110,10 +118,7 @@ set_target_properties(pysidetest PROPERTIES
 
 target_link_libraries(pysidetest
                       Shiboken6::libshiboken
-                      ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
-                      )
+                      Qt::Core Qt::Gui Qt::Widgets)
 
 add_library(testbinding MODULE ${testbinding_SRC})
 set_property(TARGET testbinding PROPERTY PREFIX "")
@@ -126,9 +131,7 @@ target_link_libraries(testbinding
                       pysidetest
                       pyside6
                       Shiboken6::libshiboken
-                      ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES})
+                      Qt::Core Qt::Gui Qt::Widgets)
 
 add_dependencies(testbinding pyside6 QtCore QtGui QtWidgets pysidetest)
 create_generator_target(testbinding)
@@ -145,10 +148,12 @@ 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)
 PYSIDE_TEST(property_python_test.py)
+PYSIDE_TEST(snake_case_test.py)
 PYSIDE_TEST(true_property_test.py)
 PYSIDE_TEST(qapp_like_a_macro_test.py)
 PYSIDE_TEST(qvariant_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
new file mode 100644
index 000000000..4a482c35a
--- /dev/null
+++ b/sources/pyside6/tests/pysidetest/snake_case_sub.py
@@ -0,0 +1,23 @@
+# 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)
+
+"""
+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()
+    check = widget.sizeHint
diff --git a/sources/pyside6/tests/pysidetest/snake_case_test.py b/sources/pyside6/tests/pysidetest/snake_case_test.py
new file mode 100644
index 000000000..14e035773
--- /dev/null
+++ b/sources/pyside6/tests/pysidetest/snake_case_test.py
@@ -0,0 +1,38 @@
+# 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)
+
+"""
+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
+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):
+        # this worked
+        widget = QWidget()
+        check = widget.size_hint
+
+        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()
diff --git a/sources/shiboken6/.cmake.conf b/sources/shiboken6/.cmake.conf
index e9e426412..ecc0a433d 100644
--- a/sources/shiboken6/.cmake.conf
+++ b/sources/shiboken6/.cmake.conf
@@ -1,5 +1,5 @@
 set(shiboken_MAJOR_VERSION "6")
-set(shiboken_MINOR_VERSION "4")
+set(shiboken_MINOR_VERSION "7")
 set(shiboken_MICRO_VERSION "0")
 set(shiboken_PRE_RELEASE_VERSION_TYPE "a")
 set(shiboken_PRE_RELEASE_VERSION "1")
diff --git a/sources/shiboken6/ApiExtractor/CMakeLists.txt b/sources/shiboken6/ApiExtractor/CMakeLists.txt
index 936def4a0..7aa2fbd11 100644
--- a/sources/shiboken6/ApiExtractor/CMakeLists.txt
+++ b/sources/shiboken6/ApiExtractor/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(apiextractor)
 
 cmake_minimum_required(VERSION 3.18)
@@ -6,53 +9,80 @@ cmake_policy(VERSION 3.18)
 set(CMAKE_AUTOMOC ON)
 
 set(apiextractor_SRC
-apiextractor.cpp
-apiextractorresult.cpp
-abstractmetaargument.cpp
-abstractmetabuilder.cpp
+abstractmetaargument.cpp abstractmetaargument.h
+abstractmetabuilder.cpp abstractmetabuilder.h abstractmetabuilder_p.h
 abstractmetabuilder_helpers.cpp
-abstractmetaenum.cpp
-abstractmetafield.cpp
-abstractmetafunction.cpp
-abstractmetatype.cpp
-abstractmetalang.cpp
-addedfunction.cpp
-classdocumentation.cpp
-codesnip.cpp
-codesniphelpers.cpp
-conditionalstreamreader.cpp
-customconversion.cpp
-documentation.cpp
-dotview.cpp
-enclosingclassmixin.cpp
-fileout.cpp
-messages.cpp
-modifications.cpp
-predefined_templates.cpp
-propertyspec.cpp
-pymethoddefentry.cpp
-reporthandler.cpp
-sourcelocation.cpp
-typeparser.cpp
-typesystem.cpp
-typesystemparser.cpp
-include.cpp
-typedatabase.cpp
-textstream.cpp
+abstractmetaenum.cpp abstractmetaenum.h
+abstractmetafield.cpp abstractmetafield.h
+abstractmetafunction.cpp abstractmetafunction.h
+abstractmetalang.cpp abstractmetalang.h abstractmetalang_helpers.h abstractmetalang_typedefs.h
+abstractmetatype.cpp abstractmetatype.h
+addedfunction.cpp addedfunction.h addedfunction_p.h
+anystringview_helpers.cpp anystringview_helpers.h
+apiextractor.cpp apiextractor.h apiextractorflags.h
+apiextractorresult.cpp apiextractorresult.h
+arraytypeentry.h
+classdocumentation.cpp classdocumentation.h
+codesnip.cpp codesnip.h
+codesniphelpers.cpp codesniphelpers.h
+complextypeentry.h
+conditionalstreamreader.cpp conditionalstreamreader.h
+configurabletypeentry.h
+constantvaluetypeentry.h
+containertypeentry.h
+customconversion.cpp customconversion.h customconversion_typedefs.h
+customtypenentry.h
+debughelpers_p.h
+dependency.h
+documentation.cpp documentation.h
+dotview.cpp dotview.h
+enclosingclassmixin.cpp enclosingclassmixin.h
+enumtypeentry.h
+enumvaluetypeentry.h
+exception.h
+fileout.cpp fileout.h
+flagstypeentry.h
+functiontypeentry.h
+graph.h
+header_paths.h
+include.cpp include.h
+messages.cpp messages.h
+modifications.cpp modifications.h modifications_typedefs.h
+namespacetypeentry.h
+objecttypeentry.h
+optionsparser.cpp optionsparser.h
+predefined_templates.cpp predefined_templates.h
+primitivetypeentry.h
+propertyspec.cpp propertyspec.h
+pymethoddefentry.cpp pymethoddefentry.h
+pythontypeentry.h
+reporthandler.cpp reporthandler.h
+smartpointertypeentry.h
+sourcelocation.cpp sourcelocation.h
+templateargumententry.h
+textstream.cpp textstream.h
+typedatabase.cpp typedatabase.h typedatabase_p.h typedatabase_typedefs.h
+typedefentry.h
+typeparser.cpp typeparser.h
+typesystem.cpp typesystem.h typesystem_enums.h typesystem_typedefs.h
+typesystemparser.cpp typesystemparser_p.h
+usingmember.h
+valuetypeentry.h
+varargstypeentry.h
+voidtypeentry.h
+xmlutils.cpp xmlutils.h xmlutils_libxslt.h xmlutils_qt.h
 # Clang
-clangparser/compilersupport.cpp
-clangparser/clangparser.cpp
-clangparser/clangbuilder.cpp
-clangparser/clangdebugutils.cpp
-clangparser/clangutils.cpp
+clangparser/clangbuilder.cpp clangparser/clangbuilder.h
+clangparser/clangdebugutils.cpp clangparser/clangdebugutils.h
+clangparser/clangparser.cpp clangparser/clangparser.h
+clangparser/clangutils.cpp clangparser/clangutils.h
+clangparser/compilersupport.cpp clangparser/compilersupport.h
 # Old parser
-parser/typeinfo.cpp
-parser/codemodel.cpp
-parser/enumvalue.cpp
-xmlutils.cpp
+parser/codemodel.cpp parser/codemodel.h parser/codemodel_fwd.h parser/codemodel_enums.h
+parser/enumvalue.cpp parser/enumvalue.h
+parser/typeinfo.cpp parser/typeinfo.h
 )
 
-find_package(Qt${QT_MAJOR_VERSION}Xml 6.0)
 find_package(LibXml2 2.6.32)
 find_package(LibXslt 1.1.19)
 
@@ -75,7 +105,7 @@ target_include_directories(apiextractor PRIVATE ${CLANG_INCLUDE_DIRS}
                                                 ${CMAKE_CURRENT_SOURCE_DIR}
                                                 ${CMAKE_CURRENT_BINARY_DIR}
                                                 ${CMAKE_CURRENT_SOURCE_DIR}/parser)
-target_link_libraries(apiextractor PUBLIC Qt${QT_MAJOR_VERSION}::Core)
+target_link_libraries(apiextractor PUBLIC Qt::Core)
 target_link_libraries(apiextractor PRIVATE libclang)
 
 if (HAS_LIBXSLT)
@@ -88,9 +118,10 @@ if (HAS_LIBXSLT)
 endif()
 
 if (NOT DISABLE_DOCSTRINGS)
-    target_sources(apiextractor PRIVATE docparser.cpp
-                                        doxygenparser.cpp
-                                        qtdocparser.cpp)
+    target_sources(apiextractor PRIVATE
+                   docparser.cpp docparser.h
+                   doxygenparser.cpp doxygenparser.h
+                   qtdocparser.cpp qtdocparser.h)
 endif()
 
 target_compile_definitions(apiextractor
@@ -100,7 +131,7 @@ target_compile_definitions(apiextractor
 set(LIB_INSTALL_DIR "lib${LIB_SUFFIX}" CACHE PATH "The subdirectory relative to the install prefix where libraries will be installed (default is /lib${LIB_SUFFIX})" FORCE)
 
 if (BUILD_TESTS)
-    find_package(Qt${QT_MAJOR_VERSION}Test 6.0 REQUIRED)
+    find_package(Qt6 REQUIRED COMPONENTS Test)
     set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/tests)
     enable_testing()
     add_subdirectory(tests)
diff --git a/sources/shiboken6/ApiExtractor/abstractmetaargument.cpp b/sources/shiboken6/ApiExtractor/abstractmetaargument.cpp
index bd6a80434..05cebe10a 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetaargument.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetaargument.cpp
@@ -38,9 +38,9 @@ AbstractMetaArgument::AbstractMetaArgument(const AbstractMetaArgument &) = defau
 
 AbstractMetaArgument &AbstractMetaArgument::operator=(const AbstractMetaArgument &) = default;
 
-AbstractMetaArgument::AbstractMetaArgument(AbstractMetaArgument &&) = default;
+AbstractMetaArgument::AbstractMetaArgument(AbstractMetaArgument &&) noexcept = default;
 
-AbstractMetaArgument &AbstractMetaArgument::operator=(AbstractMetaArgument &&) = default;
+AbstractMetaArgument &AbstractMetaArgument::operator=(AbstractMetaArgument &&) noexcept = default;
 
 const AbstractMetaType &AbstractMetaArgument::type() const
 {
@@ -191,7 +191,7 @@ QDebug operator<<(QDebug d, const AbstractMetaArgument *aa)
     d.noquote();
     d.nospace();
     d << "AbstractMetaArgument(";
-    if (aa)
+    if (aa != nullptr)
         d << aa->toString();
     else
         d << '0';
diff --git a/sources/shiboken6/ApiExtractor/abstractmetaargument.h b/sources/shiboken6/ApiExtractor/abstractmetaargument.h
index 1e5e32613..38402e369 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetaargument.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetaargument.h
@@ -19,9 +19,8 @@ public:
     ~AbstractMetaArgument();
     AbstractMetaArgument(const AbstractMetaArgument &);
     AbstractMetaArgument &operator=(const AbstractMetaArgument &);
-    AbstractMetaArgument(AbstractMetaArgument &&);
-    AbstractMetaArgument &operator=(AbstractMetaArgument &&);
-
+    AbstractMetaArgument(AbstractMetaArgument &&) noexcept;
+    AbstractMetaArgument &operator=(AbstractMetaArgument &&) noexcept;
 
     const AbstractMetaType &type() const;
     void setType(const AbstractMetaType &type);
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
index 4eff0ee62..fa0767a62 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
@@ -9,6 +9,7 @@
 #include "abstractmetatype.h"
 #include "addedfunction.h"
 #include "graph.h"
+#include "debughelpers_p.h"
 #include "exception.h"
 #include "messages.h"
 #include "propertyspec.h"
@@ -54,11 +55,9 @@
 
 using namespace Qt::StringLiterals;
 
-static inline QString colonColon() { return QStringLiteral("::"); }
-
 static QString stripTemplateArgs(const QString &name)
 {
-    int pos = name.indexOf(u'<');
+    const auto pos = name.indexOf(u'<');
     return pos < 0 ? name : name.left(pos);
 }
 
@@ -68,6 +67,31 @@ static void fixArgumentIndexes(AbstractMetaArgumentList *list)
         (*list)[i].setArgumentIndex(i);
 }
 
+bool operator<(const RejectEntry &re1, const RejectEntry &re2)
+{
+    return re1.reason != re2.reason
+        ? (re1.reason < re2.reason) : (re1.sortkey < re2.sortkey);
+}
+
+QTextStream &operator<<(QTextStream &str, const RejectEntry &re)
+{
+    str << re.signature;
+    if (!re.message.isEmpty())
+        str << ": " << re.message;
+    return str;
+}
+
+static void applyCachedFunctionModifications(AbstractMetaFunction *metaFunction,
+                                             const FunctionModificationList &functionMods)
+{
+    for (const FunctionModification &mod : functionMods) {
+        if (mod.exceptionHandling() != TypeSystem::ExceptionHandling::Unspecified)
+            metaFunction->setExceptionHandlingModification(mod.exceptionHandling());
+        if (mod.allowThread() != TypeSystem::AllowThread::Unspecified)
+            metaFunction->setAllowThreadModification(mod.allowThread());
+    }
+}
+
 bool AbstractMetaBuilderPrivate::m_useGlobalHeader = false;
 bool AbstractMetaBuilderPrivate::m_codeModelTestMode = false;
 
@@ -76,13 +100,6 @@ AbstractMetaBuilderPrivate::AbstractMetaBuilderPrivate() :
 {
 }
 
-AbstractMetaBuilderPrivate::~AbstractMetaBuilderPrivate()
-{
-    qDeleteAll(m_templates);
-    qDeleteAll(m_smartPointers);
-    qDeleteAll(m_metaClasses);
-}
-
 AbstractMetaBuilder::AbstractMetaBuilder() : d(new AbstractMetaBuilderPrivate)
 {
     d->q = this;
@@ -144,18 +161,23 @@ const QHash<TypeEntryCPtr, AbstractMetaEnum> &AbstractMetaBuilder::typeEntryToEn
     return d->m_enums;
 }
 
-void AbstractMetaBuilderPrivate::checkFunctionModifications()
+const QMultiHash<QString, QString> &AbstractMetaBuilder::typedefTargetToName() const
+{
+    return d->m_typedefTargetToName;
+}
+
+void AbstractMetaBuilderPrivate::checkFunctionModifications() const
 {
     const auto &entries = TypeDatabase::instance()->entries();
 
     for (auto it = entries.cbegin(), end = entries.cend(); it != end; ++it) {
         TypeEntryCPtr entry = it.value();
-        if (entry.isNull())
+        if (!entry)
             continue;
         if (!entry->isComplex() || !entry->generateCode())
             continue;
 
-        auto centry = qSharedPointerCast<const ComplexTypeEntry>(entry);
+        auto centry = std::static_pointer_cast<const ComplexTypeEntry>(entry);
 
         if (!centry->generateCode())
             continue;
@@ -168,7 +190,7 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications()
             QString name = signature.trimmed();
             name.truncate(name.indexOf(u'('));
 
-            AbstractMetaClass *clazz = AbstractMetaClass::findClass(m_metaClasses, centry);
+            const auto clazz = AbstractMetaClass::findClass(m_metaClasses, centry);
             if (!clazz)
                 continue;
 
@@ -198,15 +220,15 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications()
     }
 }
 
-AbstractMetaClass *AbstractMetaBuilderPrivate::argumentToClass(const ArgumentModelItem &argument,
-                                                               const AbstractMetaClass *currentClass)
+AbstractMetaClassPtr AbstractMetaBuilderPrivate::argumentToClass(const ArgumentModelItem &argument,
+                                                               const AbstractMetaClassCPtr &currentClass)
 {
-    AbstractMetaClass *returned = nullptr;
+    AbstractMetaClassPtr returned;
     auto type = translateType(argument->type(), currentClass);
     if (!type.has_value())
         return returned;
     TypeEntryCPtr entry = type->typeEntry();
-    if (!entry.isNull() && entry->isComplex())
+    if (entry && entry->isComplex())
         returned = AbstractMetaClass::findClass(m_metaClasses, entry);
     return returned;
 }
@@ -215,20 +237,20 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::argumentToClass(const ArgumentMod
  * Checks the argument of a hash function and flags the type if it is a complex type
  */
 void AbstractMetaBuilderPrivate::registerHashFunction(const FunctionModelItem &function_item,
-                                                      AbstractMetaClass *currentClass)
+                                                      const AbstractMetaClassPtr &currentClass)
 {
     if (function_item->isDeleted())
         return;
     ArgumentList arguments = function_item->arguments();
     if (arguments.size() >= 1) { // (Class, Hash seed).
-        if (AbstractMetaClass *cls = argumentToClass(arguments.at(0), currentClass))
+        if (AbstractMetaClassPtr cls = argumentToClass(arguments.at(0), currentClass))
             cls->setHashFunction(function_item->name());
     }
 }
 
 void AbstractMetaBuilderPrivate::registerToStringCapabilityIn(const NamespaceModelItem &nsItem)
 {
-    const FunctionList &streamOps = nsItem->findFunctions(u"operator<<"_s);
+    const FunctionList &streamOps = nsItem->findFunctions("operator<<");
     for (const FunctionModelItem &item : streamOps)
         registerToStringCapability(item, nullptr);
     for (const NamespaceModelItem &ni : nsItem->namespaces())
@@ -240,13 +262,13 @@ void AbstractMetaBuilderPrivate::registerToStringCapabilityIn(const NamespaceMod
  */
 
 void AbstractMetaBuilderPrivate::registerToStringCapability(const FunctionModelItem &function_item,
-                                                            AbstractMetaClass *currentClass)
+                                                            const AbstractMetaClassPtr &currentClass)
 {
     ArgumentList arguments = function_item->arguments();
     if (arguments.size() == 2) {
         if (arguments.at(0)->type().toString() == u"QDebug") {
             const ArgumentModelItem &arg = arguments.at(1);
-            if (AbstractMetaClass *cls = argumentToClass(arg, currentClass)) {
+            if (AbstractMetaClassPtr cls = argumentToClass(arg, currentClass)) {
                 if (arg->type().indirections() < 2)
                     cls->setToStringCapability(true, int(arg->type().indirections()));
             }
@@ -255,7 +277,7 @@ void AbstractMetaBuilderPrivate::registerToStringCapability(const FunctionModelI
 }
 
 void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelItem &item,
-                                                          AbstractMetaClass *currentClass)
+                                                          const AbstractMetaClassPtr &currentClass)
 {
     if (item->accessPolicy() != Access::Public)
         return;
@@ -275,7 +297,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte
     } else {
         auto type = translateType(item->type(), currentClass);
         const auto retType = type.has_value() ? type->typeEntry() : TypeEntryCPtr{};
-        AbstractMetaClass *otherArgClass = argumentToClass(itemArguments.at(1), currentClass);
+        const auto otherArgClass = argumentToClass(itemArguments.at(1), currentClass);
         if (otherArgClass && retType
             && (retType->isValue() || retType->isObject())
             && retType != baseoperandClass->typeEntry()
@@ -284,11 +306,14 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte
             firstArgumentIsSelf = false;
         }
     }
-    if (baseoperandClass == nullptr)
+    if (!baseoperandClass) {
+        rejectFunction(item, currentClass, AbstractMetaBuilder::UnmatchedOperator,
+                       u"base operand class not found."_s);
         return;
+    }
 
     if (item->isSpaceshipOperator() && !item->isDeleted()) {
-        baseoperandClass->addSynthesizedComparisonOperators();
+        AbstractMetaClass::addSynthesizedComparisonOperators(baseoperandClass);
         return;
     }
 
@@ -325,7 +350,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte
     }
     metaFunction->setFlags(flags);
     metaFunction->setAccess(Access::Public);
-    baseoperandClass->addFunction(AbstractMetaFunctionCPtr(metaFunction));
+    AbstractMetaClass::addFunction(baseoperandClass, AbstractMetaFunctionCPtr(metaFunction));
     if (!metaFunction->arguments().isEmpty()) {
         const auto include = metaFunction->arguments().constFirst().type().typeEntry()->include();
         baseoperandClass->typeEntry()->addArgumentInclude(include);
@@ -334,7 +359,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte
 }
 
 bool AbstractMetaBuilderPrivate::traverseStreamOperator(const FunctionModelItem &item,
-                                                        AbstractMetaClass *currentClass)
+                                                        const AbstractMetaClassPtr &currentClass)
 {
     ArgumentList itemArguments = item->arguments();
     if (itemArguments.size() != 2 || item->accessPolicy() != Access::Public)
@@ -361,10 +386,9 @@ bool AbstractMetaBuilderPrivate::traverseStreamOperator(const FunctionModelItem
 
     streamFunction->setArguments(arguments);
 
-    *streamFunction += AbstractMetaFunction::FinalInTargetLang;
     streamFunction->setAccess(Access::Public);
 
-    AbstractMetaClass *funcClass;
+    AbstractMetaClassPtr funcClass;
 
     if (!streamClass->typeEntry()->generateCode()) {
         AbstractMetaArgumentList reverseArgs = streamFunction->arguments();
@@ -377,7 +401,7 @@ bool AbstractMetaBuilderPrivate::traverseStreamOperator(const FunctionModelItem
         funcClass = streamClass;
     }
 
-    funcClass->addFunction(AbstractMetaFunctionCPtr(streamFunction));
+    AbstractMetaClass::addFunction(funcClass, AbstractMetaFunctionCPtr(streamFunction));
     auto funcTe = funcClass->typeEntry();
     if (funcClass == streamClass)
         funcTe->addArgumentInclude(streamedClass->typeEntry()->include());
@@ -389,7 +413,7 @@ bool AbstractMetaBuilderPrivate::traverseStreamOperator(const FunctionModelItem
 static bool metaEnumLessThan(const AbstractMetaEnum &e1, const AbstractMetaEnum &e2)
 { return e1.fullName() < e2.fullName(); }
 
-static bool metaClassLessThan(const AbstractMetaClass *c1, const AbstractMetaClass *c2)
+static bool metaClassLessThan(const AbstractMetaClassCPtr &c1, const AbstractMetaClassCPtr &c2)
 { return c1->fullName() < c2->fullName(); }
 
 static bool metaFunctionLessThan(const AbstractMetaFunctionCPtr &f1, const AbstractMetaFunctionCPtr &f2)
@@ -402,8 +426,8 @@ void AbstractMetaBuilderPrivate::sortLists()
     // this is a temporary solution before new type revision implementation
     // We need move QMetaObject register before QObject.
     Dependencies additionalDependencies;
-    if (auto qObjectClass = AbstractMetaClass::findClass(m_metaClasses, u"QObject")) {
-        if (auto qMetaObjectClass = AbstractMetaClass::findClass(m_metaClasses, u"QMetaObject")) {
+    if (auto qObjectClass = AbstractMetaClass::findClass(m_metaClasses, "QObject")) {
+        if (auto qMetaObjectClass = AbstractMetaClass::findClass(m_metaClasses, "QMetaObject")) {
             Dependency dependency;
             dependency.parent = qMetaObjectClass;
             dependency.child = qObjectClass;
@@ -412,7 +436,7 @@ void AbstractMetaBuilderPrivate::sortLists()
     }
     m_metaClasses = classesTopologicalSorted(m_metaClasses, additionalDependencies);
 
-    for (AbstractMetaClass *cls : std::as_const(m_metaClasses))
+    for (const auto &cls : std::as_const(m_metaClasses))
         cls->sortFunctions();
 
     // Ensure that indexes are in alphabetical order, roughly, except
@@ -429,7 +453,7 @@ FileModelItem AbstractMetaBuilderPrivate::buildDom(QByteArrayList arguments,
                                                    unsigned clangFlags)
 {
     clang::Builder builder;
-    builder.setSystemIncludes(TypeDatabase::instance()->systemIncludes());
+    builder.setForceProcessSystemIncludes(TypeDatabase::instance()->forceProcessSystemIncludes());
     if (addCompilerSupportArguments) {
         if (level == LanguageLevel::Default)
             level = clang::emulatedCompilerLanguageLevel();
@@ -437,7 +461,7 @@ FileModelItem AbstractMetaBuilderPrivate::buildDom(QByteArrayList arguments,
                           + clang::languageLevelOption(level));
     }
     FileModelItem result = clang::parse(arguments, addCompilerSupportArguments,
-                                        clangFlags, builder)
+                                        level, clangFlags, builder)
         ? builder.dom() : FileModelItem();
     const clang::BaseVisitor::Diagnostics &diagnostics = builder.diagnostics();
     if (const auto diagnosticsCount = diagnostics.size()) {
@@ -456,7 +480,7 @@ static QStringList functionCandidates(const AbstractMetaFunctionCList &list,
                                       const QString &signature)
 {
     QString name  = signature;
-    const int parenPos = name.indexOf(u'(');
+    const auto parenPos = name.indexOf(u'(');
     if (parenPos > 0)
         name.truncate(parenPos);
     QStringList result;
@@ -477,18 +501,18 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom,
     // Start the generation...
     const ClassList &typeValues = dom->classes();
 
-    ReportHandler::startProgress("Generating class model ("
-                                 + QByteArray::number(typeValues.size()) + ")...");
+    ReportHandler::startProgress("Generated class model ("
+                                 + QByteArray::number(typeValues.size()) + ").");
     for (const ClassModelItem &item : typeValues) {
-        if (AbstractMetaClass *cls = traverseClass(dom, item, nullptr))
-            addAbstractMetaClass(cls, item.data());
+        if (const auto cls = traverseClass(dom, item, nullptr))
+            addAbstractMetaClass(cls, item.get());
     }
 
     // We need to know all global enums
     const EnumList &enums = dom->enums();
 
-    ReportHandler::startProgress("Generating enum model ("
-                                 + QByteArray::number(enums.size()) + ")...");
+    ReportHandler::startProgress("Generated enum model ("
+                                 + QByteArray::number(enums.size()) + ").");
     for (const EnumModelItem &item : enums) {
         auto metaEnum = traverseEnum(item, nullptr, QSet<QString>());
         if (metaEnum.has_value()) {
@@ -498,19 +522,19 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom,
     }
 
     const auto &namespaceTypeValues = dom->namespaces();
-    ReportHandler::startProgress("Generating namespace model ("
-                                 + QByteArray::number(namespaceTypeValues.size()) + ")...");
+    ReportHandler::startProgress("Generated namespace model ("
+                                 + QByteArray::number(namespaceTypeValues.size()) + ").");
     for (const NamespaceModelItem &item : namespaceTypeValues)
         traverseNamespace(dom, item);
 
     // Go through all typedefs to see if we have defined any
     // specific typedefs to be used as classes.
     const TypeDefList typeDefs = dom->typeDefs();
-    ReportHandler::startProgress("Resolving typedefs ("
-                                 + QByteArray::number(typeDefs.size()) + ")...");
+    ReportHandler::startProgress("Resolved typedefs ("
+                                 + QByteArray::number(typeDefs.size()) + ").");
     for (const TypeDefModelItem &typeDef : typeDefs) {
-        if (AbstractMetaClass *cls = traverseTypeDef(dom, typeDef, nullptr))
-            addAbstractMetaClass(cls, typeDef.data());
+        if (const auto cls = traverseTypeDef(dom, typeDef, nullptr))
+            addAbstractMetaClass(cls, typeDef.get());
     }
 
     traverseTypesystemTypedefs();
@@ -528,7 +552,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom,
             continue;
 
         FunctionTypeEntryPtr funcEntry = types->findFunctionType(func->name());
-        if (funcEntry.isNull() || !funcEntry->generateCode())
+        if (!funcEntry || !funcEntry->generateCode())
             continue;
 
         AbstractMetaFunction *metaFunc = traverseFunction(func, nullptr);
@@ -548,8 +572,8 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom,
         m_globalFunctions << metaFuncPtr;
     }
 
-    ReportHandler::startProgress("Fixing class inheritance...");
-    for (AbstractMetaClass *cls : std::as_const(m_metaClasses)) {
+    ReportHandler::startProgress("Fixed class inheritance.");
+    for (const auto &cls : std::as_const(m_metaClasses)) {
         if (cls->needsInheritanceSetup()) {
             setupInheritance(cls);
             traverseUsingMembers(cls);
@@ -561,14 +585,14 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom,
         }
     }
 
-    ReportHandler::startProgress("Detecting inconsistencies in class model...");
-    for (AbstractMetaClass *cls : std::as_const(m_metaClasses)) {
-        cls->fixFunctions();
+    ReportHandler::startProgress("Checked for inconsistencies in class model.");
+    for (const auto &cls : std::as_const(m_metaClasses)) {
+        AbstractMetaClass::fixFunctions(cls);
 
         if (cls->canAddDefaultConstructor())
-             cls->addDefaultConstructor();
+            AbstractMetaClass::addDefaultConstructor(cls);
         if (cls->canAddDefaultCopyConstructor())
-            cls->addDefaultCopyConstructor();
+            AbstractMetaClass::addDefaultCopyConstructor(cls);
 
         const bool avoidProtectedHack = flags.testFlag(ApiExtractorFlag::AvoidProtectedHack);
         const bool vco =
@@ -579,10 +603,10 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom,
 
     const auto &allEntries = types->entries();
 
-    ReportHandler::startProgress("Detecting inconsistencies in typesystem ("
-                                 + QByteArray::number(allEntries.size()) + ")...");
+    ReportHandler::startProgress("Checked for inconsistencies in typesystem ("
+                                 + QByteArray::number(allEntries.size()) + ").");
     for (auto it = allEntries.cbegin(), end = allEntries.cend(); it != end; ++it) {
-        TypeEntryPtr entry = it.value();
+        const TypeEntryPtr &entry = it.value();
         if (!entry->isPrimitive()) {
             if ((entry->isValue() || entry->isObject())
                 && !types->shouldDropTypeEntry(entry->qualifiedCppName())
@@ -592,7 +616,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom,
                 && !AbstractMetaClass::findClass(m_metaClasses, entry)) {
                 qCWarning(lcShiboken, "%s", qPrintable(msgTypeNotDefined(entry)));
             } else if (entry->generateCode() && entry->type() == TypeEntry::FunctionType) {
-                auto fte = qSharedPointerCast<const FunctionTypeEntry>(entry);
+                auto fte = std::static_pointer_cast<const FunctionTypeEntry>(entry);
                 const QStringList &signatures = fte->signatures();
                 for (const QString &signature : signatures) {
                     bool ok = false;
@@ -610,9 +634,9 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom,
                     }
                 }
             } else if (entry->isEnum() && entry->generateCode()) {
-                const auto enumEntry = qSharedPointerCast<const EnumTypeEntry>(entry);
-                AbstractMetaClass *cls = AbstractMetaClass::findClass(m_metaClasses,
-                                                                      enumEntry->parent());
+                const auto enumEntry = std::static_pointer_cast<const EnumTypeEntry>(entry);
+                const auto cls = AbstractMetaClass::findClass(m_metaClasses,
+                                                              enumEntry->parent());
 
                 const bool enumFound = cls
                     ? cls->findEnum(entry->targetLangEntryName()).has_value()
@@ -629,7 +653,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom,
     }
 
     {
-        const FunctionList &hashFunctions = dom->findFunctions(u"qHash"_s);
+        const FunctionList &hashFunctions = dom->findFunctions("qHash");
         for (const FunctionModelItem &item : hashFunctions)
             registerHashFunction(item, nullptr);
     }
@@ -652,13 +676,13 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom,
         }
     }
 
-    ReportHandler::startProgress("Checking inconsistencies in function modifications...");
+    ReportHandler::startProgress("Checked for inconsistencies in function modifications.");
 
     checkFunctionModifications();
 
-    ReportHandler::startProgress("Writing log files...");
+    ReportHandler::startProgress("Wrote log files.");
 
-    for (AbstractMetaClass *cls : std::as_const(m_metaClasses)) {
+    for (const auto &cls : std::as_const(m_metaClasses)) {
 //         setupEquals(cls);
 //         setupComparable(cls);
         setupExternalConversion(cls);
@@ -702,10 +726,10 @@ bool AbstractMetaBuilder::build(const QByteArrayList &arguments,
 {
     const FileModelItem dom = d->buildDom(arguments, addCompilerSupportArguments,
                                           level, clangFlags);
-    if (dom.isNull())
+    if (!dom)
         return false;
     if (ReportHandler::isDebug(ReportHandler::MediumDebug))
-        qCDebug(lcShiboken) << dom.data();
+        qCDebug(lcShiboken) << dom.get();
     d->traverseDom(dom, apiExtractorFlags);
 
     return true;
@@ -718,7 +742,7 @@ void AbstractMetaBuilder::setLogDirectory(const QString &logDir)
        d->m_logDirectory.append(QDir::separator());
 }
 
-void AbstractMetaBuilderPrivate::addAbstractMetaClass(AbstractMetaClass *cls,
+void AbstractMetaBuilderPrivate::addAbstractMetaClass(const AbstractMetaClassPtr &cls,
                                                       const _CodeModelItem *item)
 {
     m_itemToClass.insert(item, cls);
@@ -732,23 +756,27 @@ void AbstractMetaBuilderPrivate::addAbstractMetaClass(AbstractMetaClass *cls,
     }
 }
 
-AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModelItem &dom,
-                                                                 const NamespaceModelItem &namespaceItem)
+AbstractMetaClassPtr
+    AbstractMetaBuilderPrivate::traverseNamespace(const FileModelItem &dom,
+                                                  const NamespaceModelItem &namespaceItem)
 {
-    QString namespaceName = currentScope()->qualifiedName().join(colonColon());
+    QString namespaceName = currentScope()->qualifiedName().join(u"::"_s);
     if (!namespaceName.isEmpty())
-        namespaceName.append(colonColon());
+        namespaceName.append(u"::"_s);
     namespaceName.append(namespaceItem->name());
 
     if (TypeDatabase::instance()->isClassRejected(namespaceName)) {
-        m_rejectedClasses.insert(namespaceName, AbstractMetaBuilder::GenerationDisabled);
-        return nullptr;
+        m_rejectedClasses.insert({AbstractMetaBuilder::GenerationDisabled,
+                                  namespaceName, namespaceName, QString{}});
+        return {};
     }
 
     auto type = TypeDatabase::instance()->findNamespaceType(namespaceName, namespaceItem->fileName());
     if (!type) {
-        qCWarning(lcShiboken, "%s",
-                  qPrintable(msgNamespaceNoTypeEntry(namespaceItem, namespaceName)));
+        const QString rejectReason = msgNamespaceNoTypeEntry(namespaceItem, namespaceName);
+        qCWarning(lcShiboken, "%s", qPrintable(rejectReason));
+        m_rejectedClasses.insert({AbstractMetaBuilder::GenerationDisabled,
+                                  namespaceName, namespaceName, rejectReason});
         return nullptr;
     }
 
@@ -758,22 +786,22 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
     }
 
     // Continue populating namespace?
-    AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_metaClasses, type);
+    AbstractMetaClassPtr metaClass = AbstractMetaClass::findClass(m_metaClasses, type);
     if (!metaClass) {
-        metaClass = new AbstractMetaClass;
+        metaClass.reset(new AbstractMetaClass);
         metaClass->setTypeEntry(type);
-        addAbstractMetaClass(metaClass, namespaceItem.data());
+        addAbstractMetaClass(metaClass, namespaceItem.get());
         if (auto extendsType = type->extends()) {
-            AbstractMetaClass *extended = AbstractMetaClass::findClass(m_metaClasses, extendsType);
+            const auto extended = AbstractMetaClass::findClass(m_metaClasses, extendsType);
             if (!extended) {
                 qCWarning(lcShiboken, "%s",
                           qPrintable(msgNamespaceToBeExtendedNotFound(extendsType->name(), extendsType->targetLangPackage())));
-                return nullptr;
+                return {};
             }
             metaClass->setExtendedNamespace(extended);
         }
     } else {
-        m_itemToClass.insert(namespaceItem.data(), metaClass);
+        m_itemToClass.insert(namespaceItem.get(), metaClass);
     }
 
     traverseEnums(namespaceItem, metaClass, namespaceItem->enumsDeclarations());
@@ -782,11 +810,11 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
 
     const ClassList &classes = namespaceItem->classes();
     for (const ClassModelItem &cls : classes) {
-        AbstractMetaClass *mjc = traverseClass(dom, cls, metaClass);
+        const auto mjc = traverseClass(dom, cls, metaClass);
         if (mjc) {
             metaClass->addInnerClass(mjc);
             mjc->setEnclosingClass(metaClass);
-            addAbstractMetaClass(mjc, cls.data());
+            addAbstractMetaClass(mjc, cls.get());
         }
     }
 
@@ -794,22 +822,22 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
     // specific typedefs to be used as classes.
     const TypeDefList typeDefs = namespaceItem->typeDefs();
     for (const TypeDefModelItem &typeDef : typeDefs) {
-        AbstractMetaClass *cls = traverseTypeDef(dom, typeDef, metaClass);
+        const auto cls = traverseTypeDef(dom, typeDef, metaClass);
         if (cls) {
             metaClass->addInnerClass(cls);
             cls->setEnclosingClass(metaClass);
-            addAbstractMetaClass(cls, typeDef.data());
+            addAbstractMetaClass(cls, typeDef.get());
         }
     }
 
     // Traverse namespaces recursively
     for (const NamespaceModelItem &ni : namespaceItem->namespaces()) {
-        AbstractMetaClass *mjc = traverseNamespace(dom, ni);
+        const auto mjc = traverseNamespace(dom, ni);
         if (mjc) {
             metaClass->addInnerClass(mjc);
             mjc->setEnclosingClass(metaClass);
-            m_classToItem.insert(mjc, ni.data()); // Add for enum lookup.
-            m_itemToClass.insert(ni.data(), mjc);
+            m_classToItem.insert(mjc, ni.get()); // Add for enum lookup.
+            m_itemToClass.insert(ni.get(), mjc);
         }
     }
 
@@ -823,10 +851,10 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
 
 std::optional<AbstractMetaEnum>
     AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &enumItem,
-                                             AbstractMetaClass *enclosing,
+                                             const AbstractMetaClassPtr &enclosing,
                                              const QSet<QString> &enumsDeclarations)
 {
-    QString qualifiedName = enumItem->qualifiedName().join(colonColon());
+    QString qualifiedName = enumItem->qualifiedName().join(u"::"_s);
 
     TypeEntryPtr typeEntry;
     const auto enclosingTypeEntry = enclosing ? enclosing->typeEntry() : TypeEntryCPtr{};
@@ -842,7 +870,7 @@ std::optional<AbstractMetaEnum>
         for (const EnumeratorModelItem &enumValue : enums) {
             tmpQualifiedName.removeLast();
             tmpQualifiedName << enumValue->name();
-            qualifiedName = tmpQualifiedName.join(colonColon());
+            qualifiedName = tmpQualifiedName.join(u"::"_s);
             typeEntry = TypeDatabase::instance()->findType(qualifiedName);
             if (typeEntry)
                 break;
@@ -859,66 +887,75 @@ std::optional<AbstractMetaEnum>
     if (TypeDatabase::instance()->isEnumRejected(className, enumName, &rejectReason)) {
         if (typeEntry)
             typeEntry->setCodeGeneration(TypeEntry::GenerateNothing);
-        m_rejectedEnums.insert(qualifiedName + rejectReason, AbstractMetaBuilder::GenerationDisabled);
+        m_rejectedEnums.insert({AbstractMetaBuilder::GenerationDisabled, qualifiedName,
+                                qualifiedName, rejectReason});
         return {};
     }
 
     const bool rejectionWarning = !enclosing || enclosing->typeEntry()->generateCode();
 
     if (!typeEntry) {
+        const QString rejectReason = msgNoEnumTypeEntry(enumItem, className);
         if (rejectionWarning)
-            qCWarning(lcShiboken, "%s", qPrintable(msgNoEnumTypeEntry(enumItem, className)));
-        m_rejectedEnums.insert(qualifiedName, AbstractMetaBuilder::NotInTypeSystem);
+            qCWarning(lcShiboken, "%s", qPrintable(rejectReason));
+        m_rejectedEnums.insert({AbstractMetaBuilder::NotInTypeSystem, qualifiedName,
+                                qualifiedName, rejectReason});
         return {};
     }
 
     if (!typeEntry->isEnum()) {
-        if (rejectionWarning) {
-            qCWarning(lcShiboken, "%s",
-                      qPrintable(msgNoEnumTypeConflict(enumItem, className, typeEntry)));
-        }
-        m_rejectedEnums.insert(qualifiedName, AbstractMetaBuilder::NotInTypeSystem);
+        const QString rejectReason = msgNoEnumTypeConflict(enumItem, className, typeEntry);
+        if (rejectionWarning)
+            qCWarning(lcShiboken, "%s", qPrintable(rejectReason));
+        m_rejectedEnums.insert({AbstractMetaBuilder::NotInTypeSystem, qualifiedName,
+                                qualifiedName, rejectReason});
         return {};
     }
 
     AbstractMetaEnum metaEnum;
     metaEnum.setEnumKind(enumItem->enumKind());
     metaEnum.setDeprecated(enumItem->isDeprecated());
+    metaEnum.setUnderlyingType(enumItem->underlyingType());
     metaEnum.setSigned(enumItem->isSigned());
     if (enumsDeclarations.contains(qualifiedName)
         || enumsDeclarations.contains(enumName)) {
         metaEnum.setHasQEnumsDeclaration(true);
     }
 
-    auto enumTypeEntry = qSharedPointerCast<EnumTypeEntry>(typeEntry);
+    auto enumTypeEntry = std::static_pointer_cast<EnumTypeEntry>(typeEntry);
     metaEnum.setTypeEntry(enumTypeEntry);
     metaEnum.setAccess(enumItem->accessPolicy());
     if (metaEnum.access() == Access::Private)
         typeEntry->setCodeGeneration(TypeEntry::GenerateNothing);
-
+    // PYSIDE-2088, MSVC signedness issue in Qt
+    const bool castToUnsigned = enumItem->isSigned()
+        && enumTypeEntry->cppType().contains(u"unsigned"_s);
     const EnumeratorList &enums = enumItem->enumerators();
-    for (const EnumeratorModelItem &value : enums) {
+    for (const EnumeratorModelItem &valueItem : enums) {
 
         AbstractMetaEnumValue metaEnumValue;
-        metaEnumValue.setName(value->name());
+        metaEnumValue.setName(valueItem->name());
         // Deciding the enum value...
 
-        metaEnumValue.setStringValue(value->stringValue());
-        metaEnumValue.setValue(value->value());
-        metaEnumValue.setDeprecated(value->isDeprecated());
+        metaEnumValue.setStringValue(valueItem->stringValue());
+        const auto value = valueItem->value();
+        metaEnumValue.setValue(castToUnsigned ? value.toUnsigned() : value);
+        metaEnumValue.setDeprecated(valueItem->isDeprecated());
         metaEnum.addEnumValue(metaEnumValue);
     }
 
-    if (!metaEnum.typeEntry()->include().isValid())
-        setInclude(metaEnum.typeEntry(), enumItem->fileName());
+    if (!metaEnum.typeEntry()->include().isValid()) {
+        auto te = std::const_pointer_cast<EnumTypeEntry>(metaEnum.typeEntry());
+        setInclude(te, enumItem->fileName());
+    }
 
     // Register all enum values on Type database
     const bool isScopedEnum = enumItem->enumKind() == EnumClass;
     const EnumeratorList &enumerators = enumItem->enumerators();
     for (const EnumeratorModelItem &e : enumerators) {
-        EnumValueTypeEntryPtr enumValue(new EnumValueTypeEntry(e->name(), e->stringValue(),
-                                                               enumTypeEntry, isScopedEnum,
-                                                               enumTypeEntry->version()));
+        auto enumValue = std::make_shared<EnumValueTypeEntry>(e->name(), e->stringValue(),
+                                                              enumTypeEntry, isScopedEnum,
+                                                              enumTypeEntry->version());
         TypeDatabase::instance()->addType(enumValue);
         if (e->value().isNullValue())
             enumTypeEntry->setNullValue(enumValue);
@@ -930,9 +967,31 @@ std::optional<AbstractMetaEnum>
     return metaEnum;
 }
 
-AbstractMetaClass *AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelItem &,
-                                                               const TypeDefModelItem &typeDef,
-                                                               AbstractMetaClass *currentClass)
+AbstractMetaClassPtr
+    AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelItem &dom,
+                                                const TypeDefModelItem &typeDef,
+                                                const AbstractMetaClassPtr &currentClass)
+{
+    auto result = traverseTypeDefHelper(dom, typeDef, currentClass);
+    if (!result && typeDef->type().isPlain()) {
+        const auto &type = typeDef->type();
+        QString fullName;
+        if (currentClass)
+            fullName += currentClass->qualifiedCppName() + "::"_L1;
+        fullName += typeDef->name();
+        QString targetName = typeDef->type().toString();
+        m_typedefTargetToName.insert(targetName, fullName);
+        const QByteArray normalized = QMetaObject::normalizedType(targetName.toUtf8().constData());
+        if (targetName != QLatin1StringView(normalized))
+            m_typedefTargetToName.insert(QString::fromUtf8(normalized), fullName);
+    }
+    return result;
+}
+
+AbstractMetaClassPtr
+    AbstractMetaBuilderPrivate::traverseTypeDefHelper(const FileModelItem &,
+                                                      const TypeDefModelItem &typeDef,
+                                                      const AbstractMetaClassPtr &currentClass)
 {
     TypeDatabase *types = TypeDatabase::instance();
     QString className = stripTemplateArgs(typeDef->name());
@@ -941,7 +1000,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelIt
     // we have an inner class
     if (currentClass) {
         fullClassName = stripTemplateArgs(currentClass->typeEntry()->qualifiedCppName())
-                          + colonColon() + fullClassName;
+                          + u"::"_s + fullClassName;
     }
 
     // If this is the alias for a primitive type
@@ -951,7 +1010,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelIt
     const auto &targetNames = typeDef->type().qualifiedName();
     const auto pTarget = targetNames.size() == 1
         ? types->findPrimitiveType(targetNames.constFirst()) : PrimitiveTypeEntryPtr{};
-    if (!ptype.isNull()) {
+    if (ptype) {
         ptype->setReferencedTypeEntry(pTarget);
         return nullptr;
     }
@@ -960,7 +1019,8 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelIt
     // (like size_t = unsigned)? Add it to the type DB.
     if (pTarget && isCppPrimitive(basicReferencedNonBuiltinTypeEntry(pTarget))
         && currentClass == nullptr) {
-        PrimitiveTypeEntryPtr pte(new PrimitiveTypeEntry(className, {}, {}));
+        auto pte = std::make_shared<PrimitiveTypeEntry>(className, QVersionNumber{},
+                                                        TypeEntryCPtr{});
         pte->setReferencedTypeEntry(pTarget);
         pte->setBuiltIn(true);
         types->addType(pte);
@@ -969,10 +1029,10 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelIt
 
     // If we haven't specified anything for the typedef, then we don't care
     auto type = types->findComplexType(fullClassName);
-    if (type.isNull())
+    if (!type)
         return nullptr;
 
-    auto *metaClass = new AbstractMetaClass;
+    auto metaClass = std::make_shared<AbstractMetaClass>();
     metaClass->setTypeDef(true);
     metaClass->setTypeEntry(type);
     metaClass->setBaseClassNames(QStringList(typeDef->type().toString()));
@@ -991,8 +1051,8 @@ void AbstractMetaBuilderPrivate::traverseTypesystemTypedefs()
 {
     const auto &entries = TypeDatabase::instance()->typedefEntries();
     for (auto it = entries.begin(), end = entries.end(); it != end; ++it) {
-        TypedefEntryPtr te = it.value();
-        auto *metaClass = new AbstractMetaClass;
+        const TypedefEntryPtr &te = it.value();
+        auto metaClass = std::make_shared<AbstractMetaClass>();
         metaClass->setTypeDef(true);
         metaClass->setTypeEntry(te->target());
         metaClass->setBaseClassNames(QStringList(te->sourceType()));
@@ -1018,9 +1078,9 @@ void AbstractMetaBuilderPrivate::traverseTypesystemTypedefs()
     }
 }
 
-AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem &dom,
+AbstractMetaClassPtr AbstractMetaBuilderPrivate::traverseClass(const FileModelItem &dom,
                                                              const ClassModelItem &classItem,
-                                                             AbstractMetaClass *currentClass)
+                                                             const AbstractMetaClassPtr &currentClass)
 {
     QString className = stripTemplateArgs(classItem->name());
     QString fullClassName = className;
@@ -1028,7 +1088,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem
     // we have inner an class
     if (currentClass) {
         fullClassName = stripTemplateArgs(currentClass->typeEntry()->qualifiedCppName())
-                          + colonColon() + fullClassName;
+                          + u"::"_s + fullClassName;
     }
 
     const auto type = TypeDatabase::instance()->findComplexType(fullClassName);
@@ -1036,9 +1096,9 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem
 
     if (TypeDatabase::instance()->isClassRejected(fullClassName)) {
         reason = AbstractMetaBuilder::GenerationDisabled;
-    } else if (type.isNull()) {
+    } else if (!type) {
         TypeEntryPtr te = TypeDatabase::instance()->findType(fullClassName);
-        if (!te.isNull() && !te->isComplex()) {
+        if (te && !te->isComplex()) {
             reason = AbstractMetaBuilder::RedefinedToNotClass;
             // Set the default include file name
             if (!te->include().isValid())
@@ -1054,11 +1114,11 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem
             QTextStream(&fullClassName) << "anonymous struct at " << classItem->fileName()
                 << ':' << classItem->startLine();
         }
-        m_rejectedClasses.insert(fullClassName, reason);
+        m_rejectedClasses.insert({reason, fullClassName, fullClassName, QString{}});
         return nullptr;
     }
 
-    auto *metaClass = new AbstractMetaClass;
+    auto metaClass = std::make_shared<AbstractMetaClass>();
     metaClass->setSourceLocation(classItem->sourceLocation());
     metaClass->setTypeEntry(type);
     if ((type->typeFlags() & ComplexTypeEntry::ForceAbstract) != 0)
@@ -1094,7 +1154,8 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem
     auto argumentParent = typeSystemTypeEntry(metaClass->typeEntry());
     for (qsizetype i = 0; i < template_parameters.size(); ++i) {
         const TemplateParameterModelItem &param = template_parameters.at(i);
-        auto param_type = new TemplateArgumentEntry(param->name(), type->version(),
+        auto param_type =
+            std::make_shared<TemplateArgumentEntry>(param->name(), type->version(),
                                                     argumentParent);
         param_type->setOrdinal(i);
         template_args.append(TypeEntryCPtr(param_type));
@@ -1109,11 +1170,11 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem
     {
         const ClassList &innerClasses = classItem->classes();
         for (const ClassModelItem &ci : innerClasses) {
-            AbstractMetaClass *cl = traverseClass(dom, ci, metaClass);
+            const auto cl = traverseClass(dom, ci, metaClass);
             if (cl) {
                 cl->setEnclosingClass(metaClass);
                 metaClass->addInnerClass(cl);
-                addAbstractMetaClass(cl, ci.data());
+                addAbstractMetaClass(cl, ci.get());
             }
         }
 
@@ -1123,10 +1184,10 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem
     // specific typedefs to be used as classes.
     const TypeDefList typeDefs = classItem->typeDefs();
     for (const TypeDefModelItem &typeDef : typeDefs) {
-        AbstractMetaClass *cls = traverseTypeDef(dom, typeDef, metaClass);
+        const auto cls = traverseTypeDef(dom, typeDef, metaClass);
         if (cls) {
             cls->setEnclosingClass(metaClass);
-            addAbstractMetaClass(cls, typeDef.data());
+            addAbstractMetaClass(cls, typeDef.get());
         }
     }
 
@@ -1138,7 +1199,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem
 }
 
 void AbstractMetaBuilderPrivate::traverseScopeMembers(const ScopeModelItem &item,
-                                                      AbstractMetaClass *metaClass)
+                                                      const AbstractMetaClassPtr &metaClass)
 {
     // Classes/Namespace members
     traverseFields(item, metaClass);
@@ -1152,28 +1213,25 @@ void AbstractMetaBuilderPrivate::traverseScopeMembers(const ScopeModelItem &item
 
 void AbstractMetaBuilderPrivate::traverseClassMembers(const ClassModelItem &item)
 {
-    AbstractMetaClass *metaClass = m_itemToClass.value(item.data());
-    if (!metaClass)
-        return;
-
-    // Class members
-    traverseScopeMembers(item, metaClass);
+    const auto metaClass = m_itemToClass.value(item.get());
+    if (metaClass) // Class members
+        traverseScopeMembers(item, metaClass);
 }
 
-void AbstractMetaBuilderPrivate::traverseUsingMembers(AbstractMetaClass *metaClass)
+void AbstractMetaBuilderPrivate::traverseUsingMembers(const AbstractMetaClassPtr &metaClass) const
 {
     const _CodeModelItem *item = m_classToItem.value(metaClass);
     if (item == nullptr || item->kind() != _CodeModelItem::Kind_Class)
         return;
-    auto classItem = static_cast<const _ClassModelItem *>(item);
+    const auto *classItem = static_cast<const _ClassModelItem *>(item);
     for (const auto &um : classItem->usingMembers()) {
         QString className = um.className;
-        int pos = className.indexOf(u'<'); // strip "QList<value>"
+        auto pos = className.indexOf(u'<'); // strip "QList<value>"
         if (pos != -1)
             className.truncate(pos);
-        if (auto baseClass = metaClass->AbstractMetaClass::findBaseClass(className)) {
+        if (auto baseClass = findBaseClass(metaClass, className)) {
             QString name = um.memberName;
-            const int lastQualPos = name.lastIndexOf(colonColon());
+            const auto lastQualPos = name.lastIndexOf(u"::"_s);
             if (lastQualPos != -1)
                 name.remove(0, lastQualPos + 2);
             metaClass->addUsingMember({name, baseClass, um.access});
@@ -1187,7 +1245,7 @@ void AbstractMetaBuilderPrivate::traverseUsingMembers(AbstractMetaClass *metaCla
 
 void AbstractMetaBuilderPrivate::traverseNamespaceMembers(const NamespaceModelItem &item)
 {
-    AbstractMetaClass *metaClass = m_itemToClass.value(item.data());
+    const auto metaClass = m_itemToClass.value(item.get());
     if (!metaClass)
         return;
 
@@ -1202,18 +1260,18 @@ void AbstractMetaBuilderPrivate::traverseNamespaceMembers(const NamespaceModelIt
 
 static inline QString fieldSignatureWithType(const VariableModelItem &field)
 {
-    return field->name() + QStringLiteral(" -> ") + field->type().toString();
+    return field->name() + " -> "_L1 + field->type().toString();
 }
 
 static inline QString qualifiedFieldSignatureWithType(const QString &className,
                                                       const VariableModelItem &field)
 {
-    return className + colonColon() + fieldSignatureWithType(field);
+    return className + u"::"_s + fieldSignatureWithType(field);
 }
 
 std::optional<AbstractMetaField>
     AbstractMetaBuilderPrivate::traverseField(const VariableModelItem &field,
-                                              const AbstractMetaClass *cls)
+                                              const AbstractMetaClassCPtr &cls)
 {
     QString fieldName = field->name();
     QString className = cls->typeEntry()->qualifiedCppName();
@@ -1227,8 +1285,9 @@ std::optional<AbstractMetaField>
 
     QString rejectReason;
     if (TypeDatabase::instance()->isFieldRejected(className, fieldName, &rejectReason)) {
-        m_rejectedFields.insert(qualifiedFieldSignatureWithType(className, field) + rejectReason,
-                                AbstractMetaBuilder::GenerationDisabled);
+        const QString signature = qualifiedFieldSignatureWithType(className, field);
+        m_rejectedFields.insert({AbstractMetaBuilder::GenerationDisabled,
+                                 signature, signature, rejectReason});
         return {};
     }
 
@@ -1241,7 +1300,7 @@ std::optional<AbstractMetaField>
     auto metaType = translateType(fieldType, cls);
 
     if (!metaType.has_value()) {
-        const QString type = TypeInfo::resolveType(fieldType, currentScope()).qualifiedName().join(colonColon());
+        const QString type = TypeInfo::resolveType(fieldType, currentScope()).qualifiedName().join(u"::"_s);
         if (cls->typeEntry()->generateCode()) {
              qCWarning(lcShiboken, "%s",
                        qPrintable(msgSkippingField(field, cls->name(), type)));
@@ -1276,7 +1335,7 @@ static bool applyFieldModifications(AbstractMetaField *f)
 }
 
 void AbstractMetaBuilderPrivate::traverseFields(const ScopeModelItem &scope_item,
-                                                AbstractMetaClass *metaClass)
+                                                const AbstractMetaClassPtr &metaClass)
 {
     const VariableList &variables = scope_item->variables();
     for (const VariableModelItem &field : variables) {
@@ -1295,7 +1354,7 @@ void AbstractMetaBuilderPrivate::fixReturnTypeOfConversionOperator(AbstractMetaF
         return;
 
     TypeDatabase *types = TypeDatabase::instance();
-    static const QRegularExpression operatorRegExp(QStringLiteral("^operator "));
+    static const QRegularExpression operatorRegExp("^operator "_L1);
     Q_ASSERT(operatorRegExp.isValid());
     QString castTo = metaFunction->name().remove(operatorRegExp).trimmed();
 
@@ -1305,7 +1364,7 @@ void AbstractMetaBuilderPrivate::fixReturnTypeOfConversionOperator(AbstractMetaF
         castTo.remove(0, 6);
 
     TypeEntryPtr retType = types->findType(castTo);
-    if (retType.isNull())
+    if (!retType)
         return;
 
     AbstractMetaType metaType(retType);
@@ -1316,7 +1375,7 @@ void AbstractMetaBuilderPrivate::fixReturnTypeOfConversionOperator(AbstractMetaF
 AbstractMetaFunctionRawPtrList
     AbstractMetaBuilderPrivate::classFunctionList(const ScopeModelItem &scopeItem,
                                                   AbstractMetaClass::Attributes *constructorAttributes,
-                                                  AbstractMetaClass *currentClass)
+                                                  const AbstractMetaClassPtr &currentClass)
 {
     *constructorAttributes = {};
     AbstractMetaFunctionRawPtrList result;
@@ -1328,7 +1387,7 @@ AbstractMetaFunctionRawPtrList
             traverseOperatorFunction(function, currentClass);
         } else if (function->isSpaceshipOperator() && !function->isDeleted()) {
             if (currentClass)
-                currentClass->addSynthesizedComparisonOperators();
+                AbstractMetaClass::addSynthesizedComparisonOperators(currentClass);
         } else if (auto *metaFunction = traverseFunction(function, currentClass)) {
             result.append(metaFunction);
         } else if (!function->isDeleted() && function->functionType() == CodeModel::Constructor) {
@@ -1341,8 +1400,8 @@ AbstractMetaFunctionRawPtrList
     return result;
 }
 
-void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
-                                                   AbstractMetaClass *metaClass)
+void AbstractMetaBuilderPrivate::traverseFunctions(const ScopeModelItem& scopeItem,
+                                                   const AbstractMetaClassPtr &metaClass)
 {
     AbstractMetaClass::Attributes constructorAttributes;
     const AbstractMetaFunctionRawPtrList functions =
@@ -1351,7 +1410,7 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
 
     for (AbstractMetaFunction *metaFunction : functions) {
         if (metaClass->isNamespace())
-            *metaFunction += AbstractMetaFunction::Static;
+            metaFunction->setCppAttribute(FunctionAttribute::Static);
 
         const auto propertyFunction = metaClass->searchPropertyFunction(metaFunction->name());
         if (propertyFunction.index >= 0) {
@@ -1392,18 +1451,12 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
             }
         }
 
-        const bool isInvalidDestructor = metaFunction->isDestructor() && metaFunction->isPrivate();
-        const bool isInvalidConstructor = metaFunction->functionType() == AbstractMetaFunction::ConstructorFunction
-            && metaFunction->isPrivate();
-        if (isInvalidConstructor)
+        if (metaFunction->functionType() == AbstractMetaFunction::ConstructorFunction
+            && metaFunction->isPrivate()) {
             metaClass->setHasPrivateConstructor(true);
-        if ((isInvalidDestructor || isInvalidConstructor)
-            && !metaClass->hasNonPrivateConstructor()) {
-            *metaClass += AbstractMetaClass::FinalInTargetLang;
-        } else if (metaFunction->isConstructor() && !metaFunction->isPrivate()) {
-            *metaClass -= AbstractMetaClass::FinalInTargetLang;
-            metaClass->setHasNonPrivateConstructor(true);
         }
+        if (metaFunction->isConstructor() && !metaFunction->isPrivate()) // Including Copy CT
+            metaClass->setHasNonPrivateConstructor(true);
 
         if (!metaFunction->isDestructor()
             && !(metaFunction->isPrivate() && metaFunction->functionType() == AbstractMetaFunction::ConstructorFunction)) {
@@ -1414,7 +1467,7 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
             if (metaFunction->isConversionOperator())
                 fixReturnTypeOfConversionOperator(metaFunction);
 
-            metaClass->addFunction(AbstractMetaFunctionCPtr(metaFunction));
+            AbstractMetaClass::addFunction(metaClass, AbstractMetaFunctionCPtr(metaFunction));
             applyFunctionModifications(metaFunction);
         } else if (metaFunction->isDestructor()) {
             metaClass->setHasPrivateDestructor(metaFunction->isPrivate());
@@ -1430,7 +1483,7 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
     fillAddedFunctions(metaClass);
 }
 
-void AbstractMetaBuilderPrivate::fillAddedFunctions(AbstractMetaClass *metaClass)
+void AbstractMetaBuilderPrivate::fillAddedFunctions(const AbstractMetaClassPtr &metaClass)
 {
     // Add the functions added by the typesystem
     QString errorMessage;
@@ -1494,26 +1547,17 @@ void AbstractMetaBuilderPrivate::applyFunctionModifications(AbstractMetaFunction
             func->setOriginalName(func->name());
             func->setName(mod.renamedToName());
         } else if (mod.isAccessModifier()) {
-            funcRef -= AbstractMetaFunction::Friendly;
-
             if (mod.isPublic())
                 funcRef.modifyAccess(Access::Public);
             else if (mod.isProtected())
                 funcRef.modifyAccess(Access::Protected);
             else if (mod.isPrivate())
                 funcRef.modifyAccess(Access::Private);
-            else if (mod.isFriendly())
-                funcRef += AbstractMetaFunction::Friendly;
         }
-
-        if (mod.isFinal())
-            funcRef += AbstractMetaFunction::FinalInTargetLang;
-        else if (mod.isNonFinal())
-            funcRef -= AbstractMetaFunction::FinalInTargetLang;
     }
 }
 
-bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
+bool AbstractMetaBuilderPrivate::setupInheritance(const AbstractMetaClassPtr &metaClass)
 {
     if (metaClass->inheritanceDone())
         return true;
@@ -1526,11 +1570,12 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
     if (baseClasses.size() == 1 && baseClasses.constFirst().contains(u'<')) {
         TypeInfo info;
         ComplexTypeEntryPtr baseContainerType;
-        auto *templ = findTemplateClass(baseClasses.constFirst(), metaClass,
-                                        &info, &baseContainerType);
+        const auto templ = findTemplateClass(baseClasses.constFirst(), metaClass,
+                                             &info, &baseContainerType);
         if (templ) {
             setupInheritance(templ);
-            inheritTemplate(metaClass, templ, info);
+            if (!inheritTemplate(metaClass, templ, info))
+                return false;
             metaClass->typeEntry()->setBaseContainerType(templ->typeEntry());
             return true;
         }
@@ -1547,9 +1592,9 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
             return true;
         }
 
-        qCWarning(lcShiboken).noquote().nospace()
-            << QStringLiteral("template baseclass '%1' of '%2' is not known")
-                              .arg(baseClasses.constFirst(), metaClass->name());
+        qCWarning(lcShiboken, "template baseclass '%s' of '%s' is not known",
+                  qPrintable(baseClasses.constFirst()),
+                  qPrintable(metaClass->name()));
         return false;
     }
 
@@ -1584,7 +1629,7 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
         } else {
             QString message;
             QTextStream(&message) << "Class \"" << defaultSuperclassName
-                << "\" specified as \"default-superclass\" of \"" << metaClass->name()
+                << R"(" specified as "default-superclass" of ")" << metaClass->name()
                 << "\" could not be found in the code model.";
             qCWarning(lcShiboken, "%s", qPrintable(message));
         }
@@ -1594,7 +1639,7 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
 }
 
 void AbstractMetaBuilderPrivate::traverseEnums(const ScopeModelItem &scopeItem,
-                                               AbstractMetaClass *metaClass,
+                                               const AbstractMetaClassPtr &metaClass,
                                                const QStringList &enumsDeclarations)
 {
     const EnumList &enums = scopeItem->enums();
@@ -1642,7 +1687,7 @@ bool AbstractMetaBuilderPrivate::traverseAddedGlobalFunction(const AddedFunction
 
 AbstractMetaFunction *
     AbstractMetaBuilderPrivate::traverseAddedFunctionHelper(const AddedFunctionPtr &addedFunc,
-                                                            AbstractMetaClass *metaClass /* = nullptr */,
+                                                            const AbstractMetaClassPtr &metaClass /* = {} */,
                                                             QString *errorMessage)
 {
     auto returnType = translateType(addedFunc->returnType(), metaClass, {}, errorMessage);
@@ -1654,7 +1699,7 @@ AbstractMetaFunction *
         return nullptr;
     }
 
-    auto metaFunction = new AbstractMetaFunction(addedFunc);
+    auto *metaFunction = new AbstractMetaFunction(addedFunc);
     metaFunction->setType(returnType.value());
     metaFunction->setFunctionType(functionTypeFromName(addedFunc->name()));
 
@@ -1711,6 +1756,7 @@ AbstractMetaFunction *
 
     // Find the correct default values
     const FunctionModificationList functionMods = metaFunction->modifications(metaClass);
+    applyCachedFunctionModifications(metaFunction, functionMods);
     for (qsizetype i = 0; i < metaArguments.size(); ++i) {
         AbstractMetaArgument &metaArg = metaArguments[i];
 
@@ -1726,7 +1772,7 @@ AbstractMetaFunction *
 }
 
 bool AbstractMetaBuilderPrivate::traverseAddedMemberFunction(const AddedFunctionPtr &addedFunc,
-                                                             AbstractMetaClass *metaClass,
+                                                             const AbstractMetaClassPtr &metaClass,
                                                              QString *errorMessage)
 {
     AbstractMetaFunction *metaFunction =
@@ -1736,7 +1782,7 @@ bool AbstractMetaBuilderPrivate::traverseAddedMemberFunction(const AddedFunction
 
     const AbstractMetaArgumentList fargs = metaFunction->arguments();
     if (metaClass->isNamespace())
-        *metaFunction += AbstractMetaFunction::Static;
+        metaFunction->setCppAttribute(FunctionAttribute::Static);
     if (metaFunction->name() == metaClass->name()) {
         metaFunction->setFunctionType(AbstractMetaFunction::ConstructorFunction);
         if (fargs.size() == 1) {
@@ -1750,7 +1796,7 @@ bool AbstractMetaBuilderPrivate::traverseAddedMemberFunction(const AddedFunction
 
     metaFunction->setDeclaringClass(metaClass);
     metaFunction->setImplementingClass(metaClass);
-    metaClass->addFunction(AbstractMetaFunctionCPtr(metaFunction));
+    AbstractMetaClass::addFunction(metaClass, AbstractMetaFunctionCPtr(metaFunction));
     metaClass->setHasNonPrivateConstructor(true);
     return true;
 }
@@ -1786,7 +1832,7 @@ static inline QString qualifiedFunctionSignatureWithType(const FunctionModelItem
 {
     QString result = functionItem->type().toString() + u' ';
     if (!className.isEmpty())
-        result += className + colonColon();
+        result += className + u"::"_s;
     result += functionSignature(functionItem);
     return result;
 }
@@ -1898,9 +1944,48 @@ static bool applyArrayArgumentModifications(const FunctionModificationList &func
     return true;
 }
 
+// Create the meta type for a view (std::string_view -> std::string)
+static AbstractMetaType createViewOnType(const AbstractMetaType &metaType,
+                                         const TypeEntryCPtr &viewOnTypeEntry)
+{
+    auto result = metaType;
+    result.setTypeEntry(viewOnTypeEntry);
+    if (!metaType.isContainer() || !viewOnTypeEntry->isContainer())
+        return result;
+    // For containers, when sth with several template parameters
+    // (std::span<T, int N>) is mapped onto a std::vector<T>,
+    // remove the superfluous template parameters and strip 'const'.
+    const auto vcte = std::static_pointer_cast<const ContainerTypeEntry>(viewOnTypeEntry);
+    const auto &instantiations = metaType.instantiations();
+    AbstractMetaTypeList viewInstantiations;
+    const auto size = std::min(vcte->templateParameterCount(), instantiations.size());
+    for (qsizetype i = 0; i < size; ++i) {
+        auto ins = instantiations.at(i);
+        ins.setConstant(false);
+        viewInstantiations.append(ins);
+    }
+    result.setInstantiations(viewInstantiations);
+    return result;
+}
+
+void AbstractMetaBuilderPrivate::rejectFunction(const FunctionModelItem &functionItem,
+                                                const AbstractMetaClassPtr &currentClass,
+                                                AbstractMetaBuilder::RejectReason reason,
+                                                const QString &rejectReason)
+{
+    QString sortKey;
+    if (currentClass)
+        sortKey += currentClass->typeEntry()->qualifiedCppName() + u"::"_s;
+    sortKey += functionSignature(functionItem); // Sort without return type
+    const QString signatureWithType = functionItem->type().toString() + u' ' + sortKey;
+    m_rejectedFunctions.insert({reason, signatureWithType, sortKey, rejectReason});
+}
+
 AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const FunctionModelItem &functionItem,
-                                                                   AbstractMetaClass *currentClass)
+                                                                   const AbstractMetaClassPtr &currentClass)
 {
+    const auto *tdb = TypeDatabase::instance();
+
     if (!functionItem->templateParameters().isEmpty())
         return nullptr;
 
@@ -1941,20 +2026,17 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
         }
     } // PySide extensions
 
-    // Store original signature with unresolved typedefs for message/log purposes
-    const QString originalQualifiedSignatureWithReturn =
-        qualifiedFunctionSignatureWithType(functionItem, className);
-
     QString rejectReason;
-    if (TypeDatabase::instance()->isFunctionRejected(className, functionName, &rejectReason)) {
-        m_rejectedFunctions.insert(originalQualifiedSignatureWithReturn + rejectReason, AbstractMetaBuilder::GenerationDisabled);
+    if (tdb->isFunctionRejected(className, functionName, &rejectReason)) {
+        rejectFunction(functionItem, currentClass,
+                       AbstractMetaBuilder::GenerationDisabled, rejectReason);
         return nullptr;
     }
-    const QString &signature = functionSignature(functionItem);
-    const bool rejected =
-        TypeDatabase::instance()->isFunctionRejected(className, signature, &rejectReason);
 
-    if (rejected) {
+    const QString &signature = functionSignature(functionItem);
+    if (tdb->isFunctionRejected(className, signature, &rejectReason)) {
+        rejectFunction(functionItem, currentClass,
+                       AbstractMetaBuilder::GenerationDisabled, rejectReason);
         if (ReportHandler::isDebug(ReportHandler::MediumDebug)) {
             qCInfo(lcShiboken, "%s::%s was rejected by the type database (%s).",
                    qPrintable(className), qPrintable(signature), qPrintable(rejectReason));
@@ -1965,15 +2047,17 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
     if (functionItem->isFriend())
         return nullptr;
 
-    const bool deprecated = functionItem->isDeprecated();
+    const auto cppAttributes = functionItem->attributes();
+    const bool deprecated = cppAttributes.testFlag(FunctionAttribute::Deprecated);
     if (deprecated && m_skipDeprecated) {
-        m_rejectedFunctions.insert(originalQualifiedSignatureWithReturn + u" is deprecated."_s,
-                                   AbstractMetaBuilder::GenerationDisabled);
+        rejectFunction(functionItem, currentClass,
+                       AbstractMetaBuilder::GenerationDisabled, u" is deprecated."_s);
         return nullptr;
     }
 
     AbstractMetaFunction::Flags flags;
     auto *metaFunction = new AbstractMetaFunction(functionName);
+    metaFunction->setCppAttributes(cppAttributes);
     const QByteArray cSignature = signature.toUtf8();
     const QString unresolvedSignature =
         QString::fromUtf8(QMetaObject::normalizedSignature(cSignature.constData()));
@@ -1981,35 +2065,12 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
     if (functionItem->isHiddenFriend())
         flags.setFlag(AbstractMetaFunction::Flag::HiddenFriend);
     metaFunction->setSourceLocation(functionItem->sourceLocation());
-    if (deprecated)
-        *metaFunction += AbstractMetaFunction::Deprecated;
 
     // Additional check for assignment/move assignment down below
     metaFunction->setFunctionType(functionTypeFromCodeModel(functionItem->functionType()));
     metaFunction->setConstant(functionItem->isConstant());
     metaFunction->setExceptionSpecification(functionItem->exceptionSpecification());
 
-    if (functionItem->isAbstract())
-        *metaFunction += AbstractMetaFunction::Abstract;
-
-    if (functionItem->isVirtual()) {
-        *metaFunction += AbstractMetaFunction::VirtualCppMethod;
-        if (functionItem->isOverride())
-            *metaFunction += AbstractMetaFunction::OverriddenCppMethod;
-        if (functionItem->isFinal())
-            *metaFunction += AbstractMetaFunction::FinalCppMethod;
-    } else {
-        *metaFunction += AbstractMetaFunction::FinalInTargetLang;
-    }
-
-    if (functionItem->isInvokable())
-        *metaFunction += AbstractMetaFunction::Invokable;
-
-    if (functionItem->isStatic()) {
-        *metaFunction += AbstractMetaFunction::Static;
-        *metaFunction += AbstractMetaFunction::FinalInTargetLang;
-    }
-
     // Access rights
     metaFunction->setAccess(functionItem->accessPolicy());
 
@@ -2019,25 +2080,30 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
          metaFunction->setType(AbstractMetaType::createVoid());
         break;
     case AbstractMetaFunction::ConstructorFunction:
-        metaFunction->setExplicit(functionItem->isExplicit());
         metaFunction->setName(currentClass->name());
         metaFunction->setType(AbstractMetaType::createVoid());
         break;
     default: {
         TypeInfo returnType = functionItem->type();
 
-        if (TypeDatabase::instance()->isReturnTypeRejected(className, returnType.toString(), &rejectReason)) {
-            m_rejectedFunctions.insert(originalQualifiedSignatureWithReturn + rejectReason, AbstractMetaBuilder::GenerationDisabled);
+        if (tdb->isReturnTypeRejected(className, returnType.toString(), &rejectReason)) {
+            rejectFunction(functionItem, currentClass,
+                           AbstractMetaBuilder::GenerationDisabled, rejectReason);
             delete metaFunction;
             return nullptr;
         }
 
-        auto type = translateType(returnType, currentClass, {}, &errorMessage);
+        TranslateTypeFlags flags;
+        if (functionItem->scopeResolution())
+            flags.setFlag(AbstractMetaBuilder::NoClassScopeLookup);
+        auto type = translateType(returnType, currentClass, flags, &errorMessage);
         if (!type.has_value()) {
             const QString reason = msgUnmatchedReturnType(functionItem, errorMessage);
+            const QString signature = qualifiedFunctionSignatureWithType(functionItem, className);
             qCWarning(lcShiboken, "%s",
-                      qPrintable(msgSkippingFunction(functionItem, originalQualifiedSignatureWithReturn, reason)));
-            m_rejectedFunctions.insert(originalQualifiedSignatureWithReturn, AbstractMetaBuilder::UnmatchedReturnType);
+                      qPrintable(msgSkippingFunction(functionItem, signature, reason)));
+            rejectFunction(functionItem, currentClass,
+                           AbstractMetaBuilder::UnmatchedReturnType, reason);
             delete metaFunction;
             return nullptr;
         }
@@ -2067,30 +2133,37 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
     for (qsizetype i = 0; i < arguments.size(); ++i) {
         const ArgumentModelItem &arg = arguments.at(i);
 
-        if (TypeDatabase::instance()->isArgumentTypeRejected(className, arg->type().toString(), &rejectReason)) {
-            m_rejectedFunctions.insert(originalQualifiedSignatureWithReturn + rejectReason, AbstractMetaBuilder::GenerationDisabled);
+        if (tdb->isArgumentTypeRejected(className, arg->type().toString(), &rejectReason)) {
+            rejectFunction(functionItem, currentClass,
+                           AbstractMetaBuilder::GenerationDisabled, rejectReason);
             delete metaFunction;
             return nullptr;
         }
 
-        auto metaTypeO = translateType(arg->type(), currentClass, {}, &errorMessage);
+        TranslateTypeFlags flags;
+        if (arg->scopeResolution())
+            flags.setFlag(AbstractMetaBuilder::NoClassScopeLookup);
+        auto metaTypeO = translateType(arg->type(), currentClass, flags, &errorMessage);
         if (!metaTypeO.has_value()) {
             // If an invalid argument has a default value, simply remove it
             // unless the function is virtual (since the override in the
             // wrapper can then not correctly be generated).
-            if (arg->defaultValue() && !functionItem->isVirtual()) {
+            if (arg->defaultValue()
+                && !functionItem->attributes().testFlag(FunctionAttribute::Virtual)) {
                 if (!currentClass || currentClass->typeEntry()->generateCode()) {
+                    const QString signature = qualifiedFunctionSignatureWithType(functionItem, className);
                     qCWarning(lcShiboken, "%s",
-                              qPrintable(msgStrippingArgument(functionItem, i, originalQualifiedSignatureWithReturn, arg)));
+                              qPrintable(msgStrippingArgument(functionItem, i, signature,
+                                                              arg, errorMessage)));
                 }
                 break;
             }
             const QString reason = msgUnmatchedParameterType(arg, i, errorMessage);
+            const QString signature = qualifiedFunctionSignatureWithType(functionItem, className);
             qCWarning(lcShiboken, "%s",
-                      qPrintable(msgSkippingFunction(functionItem, originalQualifiedSignatureWithReturn, reason)));
-            const QString rejectedFunctionSignature = originalQualifiedSignatureWithReturn
-                + u": "_s + reason;
-            m_rejectedFunctions.insert(rejectedFunctionSignature, AbstractMetaBuilder::UnmatchedArgumentType);
+                      qPrintable(msgSkippingFunction(functionItem, signature, reason)));
+            rejectFunction(functionItem, currentClass,
+                           AbstractMetaBuilder::UnmatchedArgumentType, reason);
             delete metaFunction;
             return nullptr;
         }
@@ -2101,10 +2174,8 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
         auto viewOnTypeEntry = metaType.typeEntry()->viewOn();
         if (viewOnTypeEntry != nullptr && metaType.indirections() == 0
             && metaType.arrayElementType() == nullptr
-            && !metaType.hasInstantiations()) {
-            auto viewOn = metaType;
-            viewOn.setTypeEntry(viewOnTypeEntry);
-            metaType.setViewOn(viewOn);
+            && (!metaType.hasInstantiations() || metaType.isContainer())) {
+            metaType.setViewOn(createViewOnType(metaType, viewOnTypeEntry));
         }
 
         AbstractMetaArgument metaArgument;
@@ -2120,12 +2191,7 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
         ? AbstractMetaFunction::findClassModifications(metaFunction, currentClass)
         : AbstractMetaFunction::findGlobalModifications(metaFunction);
 
-    for (const FunctionModification &mod : functionMods) {
-        if (mod.exceptionHandling() != TypeSystem::ExceptionHandling::Unspecified)
-            metaFunction->setExceptionHandlingModification(mod.exceptionHandling());
-        if (mod.allowThread() != TypeSystem::AllowThread::Unspecified)
-            metaFunction->setAllowThreadModification(mod.allowThread());
-    }
+    applyCachedFunctionModifications(metaFunction, functionMods);
 
     // Find the correct default values
     for (qsizetype i = 0, size = metaArguments.size(); i < size; ++i) {
@@ -2186,13 +2252,13 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
     return metaFunction;
 }
 
-static TypeEntryCPtr findTypeEntryUsingContext(const AbstractMetaClass *metaClass,
+static TypeEntryCPtr findTypeEntryUsingContext(const AbstractMetaClassCPtr &metaClass,
                                                const QString& qualifiedName)
 {
     TypeEntryCPtr type;
-    QStringList context = metaClass->qualifiedCppName().split(colonColon());
+    QStringList context = metaClass->qualifiedCppName().split(u"::"_s);
     while (!type && !context.isEmpty()) {
-        type = TypeDatabase::instance()->findType(context.join(colonColon()) + colonColon() + qualifiedName);
+        type = TypeDatabase::instance()->findType(context.join(u"::"_s) + u"::"_s + qualifiedName);
         context.removeLast();
     }
     return type;
@@ -2201,18 +2267,20 @@ static TypeEntryCPtr findTypeEntryUsingContext(const AbstractMetaClass *metaClas
 // Helper for findTypeEntries/translateTypeStatic()
 TypeEntryCList AbstractMetaBuilderPrivate::findTypeEntriesHelper(const QString &qualifiedName,
                                                                  const QString &name,
-                                                                 const AbstractMetaClass *currentClass,
+                                                                 TranslateTypeFlags flags,
+                                                                 const AbstractMetaClassCPtr &currentClass,
                                                                  AbstractMetaBuilderPrivate *d)
 {
     // 5.1 - Try first using the current scope
-    if (currentClass) {
+    if (currentClass != nullptr
+        && !flags.testFlag(AbstractMetaBuilder::NoClassScopeLookup)) {
         if (auto type = findTypeEntryUsingContext(currentClass, qualifiedName))
             return {type};
 
         // 5.1.1 - Try using the class parents' scopes
         if (d && !currentClass->baseClassNames().isEmpty()) {
             const auto &baseClasses = d->getBaseClasses(currentClass);
-            for (const AbstractMetaClass *cls : baseClasses) {
+            for (const auto &cls : baseClasses) {
                 if (auto type = findTypeEntryUsingContext(cls, qualifiedName))
                     return {type};
             }
@@ -2248,11 +2316,13 @@ TypeEntryCList AbstractMetaBuilderPrivate::findTypeEntriesHelper(const QString &
 // and does some error checking.
 TypeEntryCList AbstractMetaBuilderPrivate::findTypeEntries(const QString &qualifiedName,
                                                            const QString &name,
-                                                           const AbstractMetaClass *currentClass,
+                                                           TranslateTypeFlags flags,
+                                                           const AbstractMetaClassCPtr &currentClass,
                                                            AbstractMetaBuilderPrivate *d,
                                                            QString *errorMessage)
 {
-    TypeEntryCList types = findTypeEntriesHelper(qualifiedName, name, currentClass, d);
+    TypeEntryCList types = findTypeEntriesHelper(qualifiedName, name, flags,
+                                                 currentClass, d);
     if (types.isEmpty()) {
         if (errorMessage != nullptr)
             *errorMessage = msgCannotFindTypeEntry(qualifiedName);
@@ -2264,7 +2334,7 @@ TypeEntryCList AbstractMetaBuilderPrivate::findTypeEntries(const QString &qualif
     for (qsizetype i = 0, size = types.size(); i < size; ++i) {
         const auto &e = types.at(i);
         if (e->isPrimitive()) {
-            const auto pte = qSharedPointerCast<const PrimitiveTypeEntry>(e);
+            const auto pte = std::static_pointer_cast<const PrimitiveTypeEntry>(e);
             types[i] = basicReferencedNonBuiltinTypeEntry(pte);
         }
     }
@@ -2297,10 +2367,10 @@ TypeEntryCList AbstractMetaBuilderPrivate::findTypeEntries(const QString &qualif
 // Reverse lookup of AbstractMetaType representing a template specialization
 // found during traversing function arguments to its type system typedef'ed
 // class.
-const AbstractMetaClass *AbstractMetaBuilderPrivate::resolveTypeSystemTypeDef(const AbstractMetaType &t) const
+AbstractMetaClassCPtr AbstractMetaBuilderPrivate::resolveTypeSystemTypeDef(const AbstractMetaType &t) const
 {
     if (t.hasInstantiations()) {
-        auto pred = [t](const TypeClassEntry &e) { return e.type.equals(t); };
+        auto pred = [t](const TypeClassEntry &e) { return e.type == t; };
         auto it = std::find_if(m_typeSystemTypeDefs.cbegin(), m_typeSystemTypeDefs.cend(), pred);
         if (it != m_typeSystemTypeDefs.cend())
             return it->klass;
@@ -2321,30 +2391,30 @@ static void synthesizeWarning(const AbstractMetaFunctionCPtr &f)
 }
 
 static AbstractMetaFunctionPtr
-    addMethod(AbstractMetaClass *s, const AbstractMetaType &returnType,
+    addMethod(const AbstractMetaClassPtr &s, const AbstractMetaType &returnType,
               const QString &name, bool isConst = true)
 {
-    AbstractMetaFunctionPtr function(new AbstractMetaFunction(name));
+    auto function = std::make_shared<AbstractMetaFunction>(name);
     function->setType(returnType);
-    s->addFunction(function);
+    AbstractMetaClass::addFunction(s, function);
     function->setConstant(isConst);
     synthesizeWarning(function);
     return function;
 }
 
 static AbstractMetaFunctionPtr
-    addMethod(AbstractMetaClass *s, const QString &returnTypeName,
+    addMethod(const AbstractMetaClassPtr &s, const QString &returnTypeName,
               const QString &name, bool isConst = true)
 {
     auto typeEntry = TypeDatabase::instance()->findPrimitiveType(returnTypeName);
-    Q_ASSERT(!typeEntry.isNull());
+    Q_ASSERT(typeEntry);
     AbstractMetaType returnType(typeEntry);
     returnType.decideUsagePattern();
     return addMethod(s, returnType, name, isConst);
 }
 
 // Create the instantiation type of a smart pointer
-static AbstractMetaType instantiationType(const AbstractMetaClass *s,
+static AbstractMetaType instantiationType(const AbstractMetaClassCPtr &s,
                                           const SmartPointerTypeEntryCPtr &ste)
 {
     AbstractMetaType type(s->templateArguments().constFirst());
@@ -2355,7 +2425,7 @@ static AbstractMetaType instantiationType(const AbstractMetaClass *s,
 }
 
 // Create the pointee argument of a smart pointer constructor or reset()
-static AbstractMetaArgument pointeeArgument(const AbstractMetaClass *s,
+static AbstractMetaArgument pointeeArgument(const AbstractMetaClassCPtr &s,
                                             const SmartPointerTypeEntryCPtr &ste)
 {
     AbstractMetaArgument pointee;
@@ -2366,7 +2436,7 @@ static AbstractMetaArgument pointeeArgument(const AbstractMetaClass *s,
 
 // Add the smart pointer constructors. For MSVC, (when not specifying
 // <system-header>), clang only sees the default constructor.
-static void fixSmartPointerConstructors(AbstractMetaClass *s,
+static void fixSmartPointerConstructors(const AbstractMetaClassPtr &s,
                                         const SmartPointerTypeEntryCPtr &ste)
 {
     const auto ctors = s->queryFunctions(FunctionQueryOption::Constructors);
@@ -2380,23 +2450,23 @@ static void fixSmartPointerConstructors(AbstractMetaClass *s,
     }
 
     if (!seenParameter) {
-        AbstractMetaFunctionPtr constructor(new AbstractMetaFunction(s->name()));
+        auto constructor = std::make_shared<AbstractMetaFunction>(s->name());
         constructor->setFunctionType(AbstractMetaFunction::ConstructorFunction);
         constructor->addArgument(pointeeArgument(s, ste));
-        s->addFunction(constructor);
+        AbstractMetaClass::addFunction(s, constructor);
         synthesizeWarning(constructor);
     }
 
     if (!seenDefaultConstructor) {
-        AbstractMetaFunctionPtr constructor(new AbstractMetaFunction(s->name()));
+        auto constructor = std::make_shared<AbstractMetaFunction>(s->name());
         constructor->setFunctionType(AbstractMetaFunction::ConstructorFunction);
-        s->addFunction(constructor);
+        AbstractMetaClass::addFunction(s, constructor);
         synthesizeWarning(constructor);
     }
 }
 
 // Similarly, add the smart pointer reset() functions
-static void fixSmartPointerReset(AbstractMetaClass *s,
+static void fixSmartPointerReset(const AbstractMetaClassPtr &s,
                                  const SmartPointerTypeEntryCPtr &ste)
 {
     const QString resetMethodName = ste->resetMethod();
@@ -2411,21 +2481,21 @@ static void fixSmartPointerReset(AbstractMetaClass *s,
     }
 
     if (!seenParameter) {
-        AbstractMetaFunctionPtr f(new AbstractMetaFunction(resetMethodName));
+        auto f = std::make_shared<AbstractMetaFunction>(resetMethodName);
         f->addArgument(pointeeArgument(s, ste));
-        s->addFunction(f);
+        AbstractMetaClass::addFunction(s, f);
         synthesizeWarning(f);
     }
 
     if (!seenParameterLess) {
-        AbstractMetaFunctionPtr f(new AbstractMetaFunction(resetMethodName));
-        s->addFunction(f);
+        auto f = std::make_shared<AbstractMetaFunction>(resetMethodName);
+        AbstractMetaClass::addFunction(s, f);
         synthesizeWarning(f);
     }
 }
 
 // Add the relevant missing smart pointer functions.
-static void fixSmartPointerClass(AbstractMetaClass *s,
+static void fixSmartPointerClass(const AbstractMetaClassPtr &s,
                                  const SmartPointerTypeEntryCPtr &ste)
 {
     fixSmartPointerConstructors(s, ste);
@@ -2434,43 +2504,43 @@ static void fixSmartPointerClass(AbstractMetaClass *s,
         fixSmartPointerReset(s, ste);
 
     const QString getterName = ste->getter();
-    if (s->findFunction(getterName).isNull())
+    if (!s->findFunction(getterName))
         addMethod(s, instantiationType(s, ste), getterName);
 
     const QString refCountName = ste->refCountMethodName();
-    if (!refCountName.isEmpty() && s->findFunction(refCountName).isNull())
+    if (!refCountName.isEmpty() && !s->findFunction(refCountName))
         addMethod(s, u"int"_s, refCountName);
 
     const QString valueCheckMethod = ste->valueCheckMethod();
-    if (!valueCheckMethod.isEmpty() && s->findFunction(valueCheckMethod).isNull()) {
+    if (!valueCheckMethod.isEmpty() && !s->findFunction(valueCheckMethod)) {
         auto f = addMethod(s, u"bool"_s, valueCheckMethod);
         if (valueCheckMethod == u"operator bool")
             f->setFunctionType(AbstractMetaFunction::ConversionOperator);
     }
 
     const QString nullCheckMethod = ste->nullCheckMethod();
-    if (!nullCheckMethod.isEmpty() && s->findFunction(nullCheckMethod).isNull())
+    if (!nullCheckMethod.isEmpty() && !s->findFunction(nullCheckMethod))
         addMethod(s, u"bool"_s, nullCheckMethod);
 }
 
 // Create a missing smart pointer class
-static AbstractMetaClass *createSmartPointerClass(const SmartPointerTypeEntryCPtr &ste,
-                                                  const AbstractMetaClassList &allClasses)
+static AbstractMetaClassPtr createSmartPointerClass(const SmartPointerTypeEntryCPtr &ste,
+                                                   const AbstractMetaClassList &allClasses)
 {
-    auto *result = new AbstractMetaClass();
-    result->setTypeEntry(qSharedPointerConstCast<SmartPointerTypeEntry>(ste));
-    TypeEntryCPtr templateArg(new TemplateArgumentEntry(u"T"_s, ste->version(),
-                                                        typeSystemTypeEntry(ste)));
+    auto result = std::make_shared<AbstractMetaClass>();
+    result->setTypeEntry(std::const_pointer_cast<SmartPointerTypeEntry>(ste));
+    auto templateArg = std::make_shared<TemplateArgumentEntry>(u"T"_s, ste->version(),
+                                                               typeSystemTypeEntry(ste));
     result->setTemplateArguments({templateArg});
     fixSmartPointerClass(result, ste);
     auto enclosingTe = ste->parent();
     if (!enclosingTe->isTypeSystem()) {
-        auto *enclosing = AbstractMetaClass::findClass(allClasses, enclosingTe);
-        if (enclosing == nullptr)
+        const auto enclosing = AbstractMetaClass::findClass(allClasses, enclosingTe);
+        if (!enclosing)
             throw Exception(msgEnclosingClassNotFound(ste));
         result->setEnclosingClass(enclosing);
         auto inner = enclosing->innerClasses();
-        inner.append(result);
+        inner.append(std::const_pointer_cast<const AbstractMetaClass>(result));
         enclosing->setInnerClasses(inner);
     }
     return result;
@@ -2480,10 +2550,11 @@ void AbstractMetaBuilderPrivate::fixSmartPointers()
 {
     const auto smartPointerTypes = TypeDatabase::instance()->smartPointerTypes();
     for (const auto &ste : smartPointerTypes) {
-        const AbstractMetaClass *smartPointerClass =
+        const auto smartPointerClass =
             AbstractMetaClass::findClass(m_smartPointers, ste);
         if (smartPointerClass) {
-            fixSmartPointerClass(const_cast<AbstractMetaClass *>(smartPointerClass), ste);
+            fixSmartPointerClass(std::const_pointer_cast<AbstractMetaClass>(smartPointerClass),
+                                 ste);
         } else {
             qCWarning(lcShiboken, "Synthesizing smart pointer \"%s\"...",
                       qPrintable(ste->qualifiedCppName()));
@@ -2494,7 +2565,7 @@ void AbstractMetaBuilderPrivate::fixSmartPointers()
 
 std::optional<AbstractMetaType>
     AbstractMetaBuilderPrivate::translateType(const TypeInfo &_typei,
-                                              const AbstractMetaClass *currentClass,
+                                              const AbstractMetaClassCPtr &currentClass,
                                               TranslateTypeFlags flags,
                                               QString *errorMessage)
 {
@@ -2507,9 +2578,16 @@ static bool isNumber(const QString &s)
                        [](QChar c) { return c.isDigit(); });
 }
 
+// A type entry relevant only for non type template "X<5>"
+static bool isNonTypeTemplateArgument(const TypeEntryCPtr &te)
+{
+    const auto type = te->type();
+    return type == TypeEntry::EnumValue || type == TypeEntry::ConstantValueType;
+}
+
 std::optional<AbstractMetaType>
     AbstractMetaBuilderPrivate::translateTypeStatic(const TypeInfo &_typei,
-                                                    const AbstractMetaClass *currentClass,
+                                                    const AbstractMetaClassCPtr &currentClass,
                                                     AbstractMetaBuilderPrivate *d,
                                                     TranslateTypeFlags flags,
                                                     QString *errorMessageIn)
@@ -2539,7 +2617,7 @@ std::optional<AbstractMetaType>
         qsizetype i = d ? d->m_scopes.size() - 1 : -1;
         while (i >= 0) {
             typeInfo = TypeInfo::resolveType(_typei, d->m_scopes.at(i--));
-            if (typeInfo.qualifiedName().join(colonColon()) != _typei.qualifiedName().join(colonColon()))
+            if (typeInfo.qualifiedName().join(u"::"_s) != _typei.qualifiedName().join(u"::"_s))
                 break;
         }
 
@@ -2563,7 +2641,7 @@ std::optional<AbstractMetaType>
     bool isConstCharStarCase =
             oneDimensionalArrayOfUnspecifiedSize
             && typeInfo.qualifiedName().size() == 1
-            && typeInfo.qualifiedName().at(0) == QStringLiteral("char")
+            && typeInfo.qualifiedName().at(0) == "char"_L1
             && typeInfo.indirections() == 0
             && typeInfo.isConstant()
             && typeInfo.referenceType() == NoReference
@@ -2606,8 +2684,8 @@ std::optional<AbstractMetaType>
                     arrayType.setArrayElementCount(int(elems));
             }
             auto elementTypeEntry = elementType->typeEntry();
-            TypeEntryCPtr at(new ArrayTypeEntry(elementTypeEntry, elementTypeEntry->version(),
-                                                elementTypeEntry->parent()));
+            auto at = std::make_shared<ArrayTypeEntry>(elementTypeEntry, elementTypeEntry->version(),
+                                                       elementTypeEntry->parent());
             arrayType.setTypeEntry(at);
             arrayType.decideUsagePattern();
 
@@ -2627,7 +2705,7 @@ std::optional<AbstractMetaType>
         return {};
     }
 
-    QString qualifiedName = qualifierList.join(colonColon());
+    QString qualifiedName = qualifierList.join(u"::"_s);
     QString name = qualifierList.takeLast();
 
     // 4. Special case QFlags (include instantiation in name)
@@ -2636,7 +2714,16 @@ std::optional<AbstractMetaType>
         typeInfo.clearInstantiations();
     }
 
-    const TypeEntryCList types = findTypeEntries(qualifiedName, name, currentClass, d, errorMessageIn);
+    TypeEntryCList types = findTypeEntries(qualifiedName, name, flags,
+                                           currentClass, d, errorMessageIn);
+    if (!flags.testFlag(AbstractMetaBuilder::TemplateArgument)) {
+        // Avoid clashes between QByteArray and enum value QMetaType::QByteArray
+        // unless we are looking for template arguments.
+        auto end = std::remove_if(types.begin(), types.end(),
+                                  isNonTypeTemplateArgument);
+        types.erase(end, types.end());
+    }
+
     if (types.isEmpty()) {
         if (errorMessageIn != nullptr)
             *errorMessageIn = msgUnableToTranslateType(_typei, *errorMessageIn);
@@ -2656,11 +2743,13 @@ std::optional<AbstractMetaType>
     const auto &templateArguments = typeInfo.instantiations();
     for (qsizetype t = 0, size = templateArguments.size(); t < size; ++t) {
         const  TypeInfo &ti = templateArguments.at(t);
-        auto targType = translateTypeStatic(ti, currentClass, d, flags, &errorMessage);
+        auto targType = translateTypeStatic(ti, currentClass, d,
+                                            flags | AbstractMetaBuilder::TemplateArgument,
+                                            &errorMessage);
         // For non-type template parameters, create a dummy type entry on the fly
         // as is done for classes.
         if (!targType.has_value()) {
-            const QString value = ti.qualifiedName().join(colonColon());
+            const QString value = ti.qualifiedName().join(u"::"_s);
             if (isNumber(value)) {
                 auto module = typeSystemTypeEntry(type);
                 TypeDatabase::instance()->addConstantValueTypeEntry(value, module);
@@ -2690,7 +2779,7 @@ std::optional<AbstractMetaType>
         } else {
             auto it = std::find_if(types.cbegin(), types.cend(),
                                    [instantiationType](const TypeEntryCPtr &e) {
-                auto smartPtr = qSharedPointerCast<const SmartPointerTypeEntry>(e);
+                auto smartPtr = std::static_pointer_cast<const SmartPointerTypeEntry>(e);
                 return smartPtr->matchesInstantiation(instantiationType);
             });
             if (it == types.cend()) {
@@ -2724,7 +2813,7 @@ std::optional<AbstractMetaType>
 
 std::optional<AbstractMetaType>
     AbstractMetaBuilder::translateType(const TypeInfo &_typei,
-                                       AbstractMetaClass *currentClass,
+                                       const AbstractMetaClassPtr &currentClass,
                                        TranslateTypeFlags flags,
                                        QString *errorMessage)
 {
@@ -2735,7 +2824,7 @@ std::optional<AbstractMetaType>
 
 std::optional<AbstractMetaType>
     AbstractMetaBuilder::translateType(const QString &t,
-                                      AbstractMetaClass *currentClass,
+                                      const AbstractMetaClassPtr &currentClass,
                                       TranslateTypeFlags flags,
                                       QString *errorMessageIn)
 {
@@ -2765,7 +2854,7 @@ qint64 AbstractMetaBuilderPrivate::findOutValueFromString(const QString &stringV
 
     // This is a very lame way to handle expression evaluation,
     // but it is not critical and will do for the time being.
-    static const QRegularExpression variableNameRegExp(QStringLiteral("^[a-zA-Z_][a-zA-Z0-9_]*$"));
+    static const QRegularExpression variableNameRegExp("^[a-zA-Z_][a-zA-Z0-9_]*$"_L1);
     Q_ASSERT(variableNameRegExp.isValid());
     if (!variableNameRegExp.match(stringValue).hasMatch()) {
         ok = true;
@@ -2802,9 +2891,10 @@ static bool isUnderQualifiedSpec(QStringView qualifiedType, QStringView candidat
 }
 
 QString AbstractMetaBuilder::fixEnumDefault(const AbstractMetaType &type,
-                                            const QString &expr) const
+                                            const QString &expr,
+                                            const AbstractMetaClassCPtr &klass) const
 {
-    return d->fixEnumDefault(type, expr);
+    return d->fixEnumDefault(type, expr, klass);
 }
 
 void AbstractMetaBuilder::setCodeModelTestMode(bool b)
@@ -2815,7 +2905,7 @@ void AbstractMetaBuilder::setCodeModelTestMode(bool b)
 // Helper to fix a simple default value (field or enum reference) in a
 // class context.
 QString AbstractMetaBuilderPrivate::fixSimpleDefaultValue(QStringView expr,
-                                                          const AbstractMetaClass *klass) const
+                                                          const AbstractMetaClassCPtr &klass) const
 {
     const QString field = qualifyStaticField(klass, expr);
 
@@ -2834,7 +2924,7 @@ QString AbstractMetaBuilderPrivate::fixSimpleDefaultValue(QStringView expr,
 
 // see TestResolveType::testFixDefaultArguments()
 QString AbstractMetaBuilderPrivate::fixDefaultValue(QString expr, const AbstractMetaType &type,
-                                                    const AbstractMetaClass *implementingClass) const
+                                                    const AbstractMetaClassCPtr &implementingClass) const
 {
     expr.replace(u'\n', u' '); // breaks signature parser
 
@@ -2842,7 +2932,7 @@ QString AbstractMetaBuilderPrivate::fixDefaultValue(QString expr, const Abstract
         return expr;
 
     if (type.isFlags() || type.isEnum()) {
-        expr = fixEnumDefault(type, expr);
+        expr = fixEnumDefault(type, expr, implementingClass);
     } else if (type.isContainer() && expr.contains(u'<')) {
         // Expand a container of a nested class, fex
         // "QList<FormatRange>()" -> "QList<QTextLayout::FormatRange>()"
@@ -2917,7 +3007,7 @@ QString AbstractMetaBuilderPrivate::fixDefaultValue(QString expr, const Abstract
 }
 
 QString AbstractMetaBuilder::fixDefaultValue(const QString &expr, const AbstractMetaType &type,
-                                             const AbstractMetaClass *c) const
+                                             const AbstractMetaClassCPtr &c) const
 {
     return d->fixDefaultValue(expr, type, c);
 }
@@ -2928,23 +3018,24 @@ bool AbstractMetaBuilderPrivate::isEnum(const FileModelItem &dom, const QStringL
     return item && item->kind() == _EnumModelItem::__node_kind;
 }
 
-AbstractMetaClass *AbstractMetaBuilderPrivate::findTemplateClass(const QString &name,
-                                                                 const AbstractMetaClass *context,
-                                                                 TypeInfo *info,
-                                                                 ComplexTypeEntryPtr *baseContainerType) const
+AbstractMetaClassPtr
+    AbstractMetaBuilderPrivate::findTemplateClass(const QString &name,
+                                                  const AbstractMetaClassCPtr &context,
+                                                  TypeInfo *info,
+                                                  ComplexTypeEntryPtr *baseContainerType) const
 {
     if (baseContainerType)
         baseContainerType->reset();
     auto *types = TypeDatabase::instance();
 
-    QStringList scope = context->typeEntry()->qualifiedCppName().split(colonColon());
+    QStringList scope = context->typeEntry()->qualifiedCppName().split(u"::"_s);
     QString errorMessage;
     scope.removeLast();
     for (auto i = scope.size(); i >= 0; --i) {
-        QString prefix = i > 0 ? QStringList(scope.mid(0, i)).join(colonColon()) + colonColon() : QString();
+        QString prefix = i > 0 ? QStringList(scope.mid(0, i)).join(u"::"_s) + u"::"_s : QString();
         QString completeName = prefix + name;
         const TypeInfo parsed = TypeParser::parse(completeName, &errorMessage);
-        QString qualifiedName = parsed.qualifiedName().join(colonColon());
+        QString qualifiedName = parsed.qualifiedName().join(u"::"_s);
         if (qualifiedName.isEmpty()) {
             qWarning().noquote().nospace() << "Unable to parse type \"" << completeName
                 << "\" while looking for template \"" << name << "\": " << errorMessage;
@@ -2953,8 +3044,8 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::findTemplateClass(const QString &
         if (info)
             *info = parsed;
 
-        AbstractMetaClass *templ = nullptr;
-        for (AbstractMetaClass *c : std::as_const(m_templates)) {
+        AbstractMetaClassPtr templ;
+        for (const auto &c : std::as_const(m_templates)) {
             if (c->typeEntry()->name() == qualifiedName) {
                 templ = c;
                 break;
@@ -2975,7 +3066,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::findTemplateClass(const QString &
 }
 
 AbstractMetaClassCList
-    AbstractMetaBuilderPrivate::getBaseClasses(const AbstractMetaClass *metaClass) const
+    AbstractMetaBuilderPrivate::getBaseClasses(const AbstractMetaClassCPtr &metaClass) const
 {
     // Shortcut if inheritance has already been set up
     if (metaClass->inheritanceDone() || !metaClass->needsInheritanceSetup())
@@ -2983,11 +3074,9 @@ AbstractMetaClassCList
     AbstractMetaClassCList baseClasses;
     const QStringList &baseClassNames = metaClass->baseClassNames();
     for (const QString& parent : baseClassNames) {
-        AbstractMetaClass *cls = nullptr;
-        if (parent.contains(u'<'))
-            cls = findTemplateClass(parent, metaClass);
-        else
-            cls = AbstractMetaClass::findClass(m_metaClasses, parent);
+        const auto cls = parent.contains(u'<')
+            ? findTemplateClass(parent, metaClass)
+            : AbstractMetaClass::findClass(m_metaClasses, parent);
 
         if (cls)
             baseClasses << cls;
@@ -3007,7 +3096,7 @@ std::optional<AbstractMetaType>
     returned.setOriginalTemplateType(metaType);
 
     if (returned.typeEntry()->isTemplateArgument()) {
-        const auto tae = qSharedPointerCast<const TemplateArgumentEntry>(returned.typeEntry());
+        const auto tae = std::static_pointer_cast<const TemplateArgumentEntry>(returned.typeEntry());
 
         // If the template is intantiated with void we special case this as rejecting the functions that use this
         // parameter from the instantiation.
@@ -3037,83 +3126,106 @@ std::optional<AbstractMetaType>
     return returned;
 }
 
-AbstractMetaClass *
+AbstractMetaClassPtr
     AbstractMetaBuilder::inheritTemplateClass(const ComplexTypeEntryPtr &te,
-                                              const AbstractMetaClass *templateClass,
-                                              const AbstractMetaTypeList &templateTypes,
-                                              InheritTemplateFlags flags)
+                                              const AbstractMetaClassCPtr &templateClass,
+                                              const AbstractMetaTypeList &templateTypes)
 {
-    auto result = std::make_unique<AbstractMetaClass>();
+    auto result = std::make_shared<AbstractMetaClass>();
     result->setTypeDef(true);
 
     result->setTypeEntry(te);
-    if (!AbstractMetaBuilderPrivate::inheritTemplate(result.get(), templateClass,
-                                                     templateTypes, flags)) {
-        return nullptr;
+    if (!AbstractMetaBuilderPrivate::inheritTemplate(result, templateClass,
+                                                     templateTypes)) {
+        return {};
     }
-    AbstractMetaBuilderPrivate::inheritTemplateFunctions(result.get());
-    return result.release();
+    AbstractMetaBuilderPrivate::inheritTemplateFunctions(result);
+    return result;
 }
 
-bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass,
-                                                 const AbstractMetaClass *templateClass,
+
+static std::optional<AbstractMetaType>
+    inheritTemplateParameter(const AbstractMetaClassPtr &subclass,
+                             const AbstractMetaClassCPtr &templateClass,
+                             const TypeInfo &info, QString *errorMessage)
+{
+    QString typeName = info.qualifiedName().join("::"_L1);
+    TypeDatabase *typeDb = TypeDatabase::instance();
+    TypeEntryPtr t;
+    // Check for a non-type template integer parameter, that is, for a base
+    // "template <int R, int C> Matrix<R, C>" and subclass
+    // "typedef Matrix<2,3> Matrix2x3;". If so, create dummy entries of
+    // EnumValueTypeEntry for the integer values encountered on the fly.
+    if (isNumber(typeName)) {
+        t = typeDb->findType(typeName);
+        if (!t) {
+            auto parent = typeSystemTypeEntry(subclass->typeEntry());
+            t = TypeDatabase::instance()->addConstantValueTypeEntry(typeName, parent);
+        }
+    } else {
+        QStringList possibleNames;
+        possibleNames << subclass->qualifiedCppName() + "::"_L1 + typeName;
+        possibleNames << templateClass->qualifiedCppName() + "::"_L1 + typeName;
+        if (subclass->enclosingClass())
+            possibleNames << subclass->enclosingClass()->qualifiedCppName() + "::"_L1 + typeName;
+        possibleNames << typeName;
+
+        for (const QString &possibleName : std::as_const(possibleNames)) {
+            t = typeDb->findType(possibleName);
+            if (t)
+                break;
+        }
+    }
+
+    if (!t) {
+        *errorMessage = msgIgnoringTemplateParameter(typeName,
+                            "The corresponding type was not found in the typesystem.");
+        return std::nullopt;
+    }
+
+    if (t->isContainer()) {
+        *errorMessage = msgIgnoringTemplateParameter(typeName,
+                            "Template inheritance from nested containers is not supported");
+        return std::nullopt;
+    }
+    AbstractMetaType result(t);
+    result.setConstant(info.isConstant());
+    result.setReferenceType(info.referenceType());
+    result.setIndirectionsV(info.indirectionsV());
+    result.decideUsagePattern();
+    return result;
+}
+
+bool AbstractMetaBuilderPrivate::inheritTemplate(const AbstractMetaClassPtr &subclass,
+                                                 const AbstractMetaClassCPtr &templateClass,
                                                  const TypeInfo &info)
 {
     AbstractMetaTypeList  templateTypes;
 
+    QString errorMessage;
     for (const TypeInfo &i : info.instantiations()) {
-        QString typeName = i.qualifiedName().join(colonColon());
-        TypeDatabase *typeDb = TypeDatabase::instance();
-        TypeEntryPtr t;
-        // Check for a non-type template integer parameter, that is, for a base
-        // "template <int R, int C> Matrix<R, C>" and subclass
-        // "typedef Matrix<2,3> Matrix2x3;". If so, create dummy entries of
-        // EnumValueTypeEntry for the integer values encountered on the fly.
-        if (isNumber(typeName)) {
-            t = typeDb->findType(typeName);
-            if (!t) {
-                auto parent = typeSystemTypeEntry(subclass->typeEntry());
-                t = TypeDatabase::instance()->addConstantValueTypeEntry(typeName, parent);
-            }
+        const auto typeO = inheritTemplateParameter(subclass, templateClass, i, &errorMessage);
+        if (typeO.has_value()) {
+            templateTypes.append(typeO.value());
         } else {
-            QStringList possibleNames;
-            possibleNames << subclass->qualifiedCppName() + colonColon() + typeName;
-            possibleNames << templateClass->qualifiedCppName() + colonColon() + typeName;
-            if (subclass->enclosingClass())
-                possibleNames << subclass->enclosingClass()->qualifiedCppName() + colonColon() + typeName;
-            possibleNames << typeName;
-
-            for (const QString &possibleName : std::as_const(possibleNames)) {
-                t = typeDb->findType(possibleName);
-                if (t)
-                    break;
-            }
-        }
-
-        if (t) {
-            AbstractMetaType temporaryType(t);
-            temporaryType.setConstant(i.isConstant());
-            temporaryType.setReferenceType(i.referenceType());
-            temporaryType.setIndirectionsV(i.indirectionsV());
-            temporaryType.decideUsagePattern();
-            templateTypes << temporaryType;
-        } else {
-            qCWarning(lcShiboken).noquote().nospace()
-                << "Ignoring template parameter " << typeName << " from "
-                << info.toString() << ". The corresponding type was not found in the typesystem.";
+            errorMessage = msgInheritTemplateIssue(subclass, info, errorMessage);
+            qCWarning(lcShiboken, "%s", qPrintable(errorMessage));
         }
     }
+    if (templateTypes.isEmpty()) {
+         errorMessage = msgInheritTemplateIssue(subclass, info,
+                                                "No template parameters could be inherited"_L1);
+         qCWarning(lcShiboken, "%s", qPrintable(errorMessage));
+         return false;
+    }
     return inheritTemplate(subclass, templateClass, templateTypes);
 }
 
-bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass,
-                                                 const AbstractMetaClass *templateClass,
-                                                 const AbstractMetaTypeList &templateTypes,
-                                                 InheritTemplateFlags flags)
+bool AbstractMetaBuilderPrivate::inheritTemplate(const AbstractMetaClassPtr &subclass,
+                                                 const AbstractMetaClassCPtr &templateClass,
+                                                 const AbstractMetaTypeList &templateTypes)
 {
     subclass->setTemplateBaseClass(templateClass);
-    if (flags.testFlag(InheritTemplateFlag::SetEnclosingClass))
-        subclass->setEnclosingClass(templateClass->enclosingClass());
     subclass->setTemplateBaseClassInstantiations(templateTypes);
     subclass->setBaseClass(templateClass->baseClass());
     return true;
@@ -3157,11 +3269,11 @@ AbstractMetaFunctionPtr
 AbstractMetaFunctionPtr
     AbstractMetaBuilderPrivate::inheritTemplateMember(const AbstractMetaFunctionCPtr &function,
                                                       const AbstractMetaTypeList &templateTypes,
-                                                      const AbstractMetaClass *templateClass,
-                                                      AbstractMetaClass *subclass)
+                                                      const AbstractMetaClassCPtr &templateClass,
+                                                      const AbstractMetaClassPtr &subclass)
 {
     AbstractMetaFunctionPtr f = inheritTemplateFunction(function, templateTypes);
-    if (f.isNull())
+    if (!f)
         return {};
 
     // There is no base class in the target language to inherit from here, so
@@ -3215,8 +3327,8 @@ AbstractMetaFunctionPtr
 AbstractMetaFunctionPtr
     AbstractMetaBuilder::inheritTemplateMember(const AbstractMetaFunctionCPtr &function,
                                                const AbstractMetaTypeList &templateTypes,
-                                               const AbstractMetaClass *templateClass,
-                                               AbstractMetaClass *subclass)
+                                               const AbstractMetaClassCPtr &templateClass,
+                                               const AbstractMetaClassPtr &subclass)
 {
     return AbstractMetaBuilderPrivate::inheritTemplateMember(function, templateTypes,
                                                              templateClass, subclass);
@@ -3224,8 +3336,8 @@ AbstractMetaFunctionPtr
 
 static bool doInheritTemplateFunction(const AbstractMetaFunctionCPtr &function,
                                       const AbstractMetaFunctionCList &existingSubclassFuncs,
-                                      const AbstractMetaClass *templateBaseClass,
-                                      const AbstractMetaClass *subclass)
+                                      const AbstractMetaClassCPtr &templateBaseClass,
+                                      const AbstractMetaClassCPtr &subclass)
 {
     // If the function is modified or the instantiation has an equally named
     // function we are shadowing, so we need to skip it (unless the subclass
@@ -3238,7 +3350,7 @@ static bool doInheritTemplateFunction(const AbstractMetaFunctionCPtr &function,
         || subclass->isUsingMember(templateBaseClass, function->name(), Access::Protected);
 }
 
-void AbstractMetaBuilderPrivate::inheritTemplateFunctions(AbstractMetaClass *subclass)
+void AbstractMetaBuilderPrivate::inheritTemplateFunctions(const AbstractMetaClassPtr &subclass)
 {
     auto templateClass = subclass->templateBaseClass();
 
@@ -3259,8 +3371,8 @@ void AbstractMetaBuilderPrivate::inheritTemplateFunctions(AbstractMetaClass *sub
                                       templateClass, subclass)) {
             AbstractMetaFunctionCPtr f = inheritTemplateMember(function, templateTypes,
                                                                templateClass, subclass);
-            if (!f.isNull())
-                subclass->addFunction(f);
+            if (f)
+                AbstractMetaClass::addFunction(subclass, f);
         }
     }
 
@@ -3285,7 +3397,7 @@ void AbstractMetaBuilderPrivate::inheritTemplateFunctions(AbstractMetaClass *sub
     }
 }
 
-void AbstractMetaBuilderPrivate::parseQ_Properties(AbstractMetaClass *metaClass,
+void AbstractMetaBuilderPrivate::parseQ_Properties(const AbstractMetaClassPtr &metaClass,
                                                    const QStringList &declarations)
 {
     const QStringList scopes = currentScope()->qualifiedName();
@@ -3296,7 +3408,7 @@ void AbstractMetaBuilderPrivate::parseQ_Properties(AbstractMetaClass *metaClass,
         if (spec.has_value()) {
             spec->setIndex(i);
             metaClass->addPropertySpec(spec.value());
-        } else {
+        } else if (!errorMessage.isEmpty()) {
             QString message;
             QTextStream str(&message);
             str << metaClass->sourceLocation() << errorMessage;
@@ -3325,24 +3437,35 @@ void AbstractMetaBuilderPrivate::parseQ_Properties(AbstractMetaClass *metaClass,
     }
 }
 
-void AbstractMetaBuilderPrivate::setupExternalConversion(const AbstractMetaClass *cls)
+void AbstractMetaBuilderPrivate::setupExternalConversion(const AbstractMetaClassCPtr &cls)
 {
     const auto &convOps = cls->operatorOverloads(OperatorQueryOption::ConversionOp);
     for (const auto &func : convOps) {
         if (func->isModifiedRemoved())
             continue;
-        AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_metaClasses, func->type().typeEntry());
+        const auto metaClass =
+            AbstractMetaClass::findClass(m_metaClasses, func->type().typeEntry());
         if (!metaClass)
             continue;
         metaClass->addExternalConversionOperator(func);
     }
-    for (auto *innerClass : cls->innerClasses())
+    for (const auto &innerClass : cls->innerClasses())
         setupExternalConversion(innerClass);
 }
 
 static void writeRejectLogFile(const QString &name,
-                                  const QMap<QString, AbstractMetaBuilder::RejectReason> &rejects)
-{
+                               const AbstractMetaBuilderPrivate::RejectSet &rejects)
+{
+    static const QHash<AbstractMetaBuilder::RejectReason, QByteArray> descriptions ={
+        {AbstractMetaBuilder::NotInTypeSystem,  "Not in type system"_ba},
+        {AbstractMetaBuilder::GenerationDisabled, "Generation disabled by type system"_ba},
+        {AbstractMetaBuilder::RedefinedToNotClass, "Type redefined to not be a class"_ba},
+        {AbstractMetaBuilder::UnmatchedReturnType, "Unmatched return type"_ba},
+        {AbstractMetaBuilder::UnmatchedArgumentType, "Unmatched argument type"_ba},
+        {AbstractMetaBuilder::UnmatchedOperator, "Unmatched operator"_ba},
+        {AbstractMetaBuilder::Deprecated, "Deprecated"_ba}
+    };
+
     QFile f(name);
     if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
         qCWarning(lcShiboken, "%s", qPrintable(msgCannotOpenForWriting(f)));
@@ -3351,53 +3474,19 @@ static void writeRejectLogFile(const QString &name,
 
     QTextStream s(&f);
 
-
-    for (int reason = 0; reason < AbstractMetaBuilder::NoReason; ++reason) {
-        s << QByteArray(72, '*') << '\n';
-        switch (reason) {
-        case AbstractMetaBuilder::NotInTypeSystem:
-            s << "Not in type system";
-            break;
-        case AbstractMetaBuilder::GenerationDisabled:
-            s << "Generation disabled by type system";
-            break;
-        case AbstractMetaBuilder::RedefinedToNotClass:
-            s << "Type redefined to not be a class";
-            break;
-
-        case AbstractMetaBuilder::UnmatchedReturnType:
-            s << "Unmatched return type";
-            break;
-
-        case AbstractMetaBuilder::UnmatchedArgumentType:
-            s << "Unmatched argument type";
-            break;
-
-        case AbstractMetaBuilder::ApiIncompatible:
-            s << "Incompatible API";
-            break;
-
-        case AbstractMetaBuilder::Deprecated:
-            s << "Deprecated";
-            break;
-
-        default:
-            s << "unknown reason";
-            break;
-        }
-
-        s << Qt::endl;
-
-        for (QMap<QString, AbstractMetaBuilder::RejectReason>::const_iterator it = rejects.constBegin();
-             it != rejects.constEnd(); ++it) {
-            if (it.value() != reason)
-                continue;
-            s << " - " << it.key() << Qt::endl;
+    int lastReason = -1;
+    for (const auto &e : rejects) {
+        if (e.reason != lastReason) {
+            const QByteArray description = descriptions.value(e.reason, "Unknown reason"_ba);
+            const QByteArray underline(description.size(), '*');
+            if (lastReason != -1)
+                s << '\n';
+            s << underline << '\n' << description << '\n' << underline << "\n\n";
+            lastReason = e.reason;
         }
 
-        s << QByteArray(72, '*') << "\n\n";
+        s << " - " << e << '\n';
     }
-
 }
 
 void AbstractMetaBuilderPrivate::dumpLog() const
@@ -3412,10 +3501,10 @@ void AbstractMetaBuilderPrivate::dumpLog() const
 // AbstractMetaClassList/AbstractMetaClassCList.
 // Add a dependency of the class associated with typeEntry on clazz.
 template <class MetaClass>
-static bool addClassDependency(const QList<MetaClass *> &classList,
+static bool addClassDependency(const QList<std::shared_ptr<MetaClass> > &classList,
                                const TypeEntryCPtr &typeEntry,
-                               MetaClass *clazz,
-                               Graph<MetaClass *> *graph)
+                               std::shared_ptr<MetaClass> clazz,
+                               Graph<std::shared_ptr<MetaClass> > *graph)
 {
     if (!typeEntry->isComplex() || typeEntry == clazz->typeEntry())
         return false;
@@ -3426,10 +3515,11 @@ static bool addClassDependency(const QList<MetaClass *> &classList,
 }
 
 template <class MetaClass>
-static QList<MetaClass *> topologicalSortHelper(const QList<MetaClass *> &classList,
-                                                const Dependencies &additionalDependencies)
+static QList<std::shared_ptr<MetaClass> >
+    topologicalSortHelper(const QList<std::shared_ptr<MetaClass> > &classList,
+                          const Dependencies &additionalDependencies)
 {
-    Graph<MetaClass *> graph(classList.cbegin(), classList.cend());
+    Graph<std::shared_ptr<MetaClass> > graph(classList.cbegin(), classList.cend());
 
     for (const auto &dep : additionalDependencies) {
         if (!graph.addEdge(dep.parent, dep.child)) {
@@ -3439,14 +3529,14 @@ static QList<MetaClass *> topologicalSortHelper(const QList<MetaClass *> &classL
         }
     }
 
-    for (auto *clazz : classList) {
+    for (const auto &clazz : classList) {
         if (auto enclosingC = clazz->enclosingClass()) {
-            auto enclosing = const_cast<AbstractMetaClass *>(enclosingC);
+            const auto enclosing = std::const_pointer_cast<MetaClass>(enclosingC);
             graph.addEdge(enclosing, clazz);
         }
 
-        for (auto baseClass : clazz->baseClasses())
-            graph.addEdge(const_cast<MetaClass *>(baseClass), clazz);
+        for (const auto &baseClass : clazz->baseClasses())
+            graph.addEdge(std::const_pointer_cast<MetaClass>(baseClass), clazz);
 
         for (const auto &func : clazz->functions()) {
             const AbstractMetaArgumentList &arguments = func->arguments();
@@ -3474,16 +3564,22 @@ static QList<MetaClass *> topologicalSortHelper(const QList<MetaClass *> &classL
     if (!result.isValid() && graph.nodeCount()) {
         QTemporaryFile tempFile(QDir::tempPath() + u"/cyclic_depXXXXXX.dot"_s);
         tempFile.setAutoRemove(false);
-        tempFile.open();
-        graph.dumpDot(tempFile.fileName(),
-                      [] (const AbstractMetaClass *c) { return c->name(); });
+        const bool ok = tempFile.open();
+        if (ok) {
+            graph.dumpDot(tempFile.fileName(),
+                          [] (const AbstractMetaClassCPtr &c) { return c->name(); });
+        }
 
         QString message;
         QTextStream str(&message);
         str << "Cyclic dependency of classes found:";
-        for (auto c : result.cyclic)
+        for (const auto &c : result.cyclic)
             str << ' ' << c->name();
-        str << ". Graph can be found at \"" << QDir::toNativeSeparators(tempFile.fileName()) << '"';
+        str << '.';
+        if (ok) {
+            str << " Graph can be found at \""
+                << QDir::toNativeSeparators(tempFile.fileName()) << '"';
+        }
         qCWarning(lcShiboken, "%s", qPrintable(message));
     }
 
@@ -3517,8 +3613,8 @@ void AbstractMetaBuilderPrivate::pushScope(const NamespaceModelItem &item)
         }
     }
     if (candidates.size() > 1) {
-        NamespaceModelItem joined(new _NamespaceModelItem(m_scopes.constLast()->model(),
-                                                          name, _CodeModelItem::Kind_Namespace));
+        auto joined = std::make_shared<_NamespaceModelItem>(m_scopes.constLast()->model(),
+                                                            name, _CodeModelItem::Kind_Namespace);
         joined->setScope(item->scope());
         for (const auto &n : candidates)
             joined->appendNamespace(*n);
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
index 04069cefc..20261ed3c 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
@@ -29,13 +29,15 @@ class TypeEntry;
 class AbstractMetaBuilder
 {
 public:
+    Q_DISABLE_COPY_MOVE(AbstractMetaBuilder)
+
     enum RejectReason {
         NotInTypeSystem,
         GenerationDisabled,
         RedefinedToNotClass,
         UnmatchedArgumentType,
         UnmatchedReturnType,
-        ApiIncompatible,
+        UnmatchedOperator,
         Deprecated,
         NoReason
     };
@@ -52,6 +54,7 @@ public:
     const AbstractMetaFunctionCList &globalFunctions() const;
     const AbstractMetaEnumList &globalEnums() const;
     const QHash<TypeEntryCPtr, AbstractMetaEnum> &typeEntryToEnumsHash() const;
+    const QMultiHash<QString, QString> &typedefTargetToName() const;
 
     bool build(const QByteArrayList &arguments,
                ApiExtractorFlags apiExtractorFlags = {},
@@ -75,15 +78,17 @@ public:
     void setApiExtractorFlags(ApiExtractorFlags flags);
 
     enum TranslateTypeFlag {
-        DontResolveType = 0x1
+        DontResolveType = 0x1,
+        TemplateArgument = 0x2,
+        NoClassScopeLookup = 0x4
     };
     Q_DECLARE_FLAGS(TranslateTypeFlags, TranslateTypeFlag);
 
     static std::optional<AbstractMetaType>
-        translateType(const TypeInfo &_typei, AbstractMetaClass *currentClass = nullptr,
+        translateType(const TypeInfo &_typei, const AbstractMetaClassPtr &currentClass = {},
                       TranslateTypeFlags flags = {}, QString *errorMessage = nullptr);
     static std::optional<AbstractMetaType>
-        translateType(const QString &t, AbstractMetaClass *currentClass = nullptr,
+        translateType(const QString &t, const AbstractMetaClassPtr &currentClass = {},
                       TranslateTypeFlags flags = {}, QString *errorMessage = nullptr);
 
     /// Performs a template specialization of the function.
@@ -94,11 +99,10 @@ public:
         inheritTemplateFunction(const AbstractMetaFunctionCPtr &function,
                                 const AbstractMetaTypeList &templateTypes);
 
-    static AbstractMetaClass *
-        inheritTemplateClass(const ComplexTypeEntryPtr &te,
-                             const AbstractMetaClass *templateClass,
-                             const AbstractMetaTypeList &templateTypes,
-                             InheritTemplateFlags flags = {});
+    static AbstractMetaClassPtr
+    inheritTemplateClass(const ComplexTypeEntryPtr &te,
+                         const AbstractMetaClassCPtr &templateClass,
+                         const AbstractMetaTypeList &templateTypes);
 
     /// Performs a template specialization of the member function.
     /// \param function Member function
@@ -109,23 +113,24 @@ public:
     static AbstractMetaFunctionPtr
         inheritTemplateMember(const AbstractMetaFunctionCPtr &function,
                               const AbstractMetaTypeList &templateTypes,
-                              const AbstractMetaClass *templateClass,
-                              AbstractMetaClass *subclass);
+                              const AbstractMetaClassCPtr &templateClass,
+                              const AbstractMetaClassPtr &subclass);
 
     static QString getSnakeCaseName(const QString &name);
     // Names under which an item will be registered to Python depending on snakeCase
     static QStringList definitionNames(const QString &name,
                                        TypeSystem::SnakeCase snakeCase);
 
-    static QString resolveScopePrefix(const AbstractMetaClass *scope,
+    static QString resolveScopePrefix(const AbstractMetaClassCPtr &scope,
                                       QStringView value);
 
     static bool dontFixDefaultValue(QStringView expr);
 
     // For testing purposes
     QString fixDefaultValue(const QString &expr, const AbstractMetaType &type,
-                            const AbstractMetaClass *) const;
-    QString fixEnumDefault(const AbstractMetaType &type, const QString &expr) const;
+                            const AbstractMetaClassCPtr &) const;
+    QString fixEnumDefault(const AbstractMetaType &type, const QString &expr,
+                           const AbstractMetaClassCPtr & = {}) const;
 
     static void setCodeModelTestMode(bool b);
 
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder_helpers.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder_helpers.cpp
index 7695aabfc..68eef737a 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder_helpers.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder_helpers.cpp
@@ -30,7 +30,7 @@ static QString resolveScopePrefixHelper(const QStringViewList &scopeList,
     return name;
 }
 
-QString AbstractMetaBuilder::resolveScopePrefix(const AbstractMetaClass *scope,
+QString AbstractMetaBuilder::resolveScopePrefix(const AbstractMetaClassCPtr &scope,
                                                 QStringView value)
 {
     if (!scope)
@@ -45,7 +45,7 @@ QString AbstractMetaBuilder::resolveScopePrefix(const AbstractMetaClass *scope,
 static QString resolveEnumValueScopePrefix(const AbstractMetaEnum &metaEnum,
                                            QStringView value)
 {
-    const AbstractMetaClass *scope = metaEnum.enclosingClass();
+    AbstractMetaClassCPtr scope = metaEnum.enclosingClass();
     if (!scope)
         return {}; // global enum, value should work as is
     const QString &qualifiedCppName = scope->qualifiedCppName();
@@ -85,21 +85,26 @@ static bool isFloatConstant(const QStringView expr)
 // to the default value, making it usable from Python wrapper code outside the
 // owner class hierarchy. See TestEnum::testEnumDefaultValues().
 QString AbstractMetaBuilderPrivate::fixEnumDefault(const AbstractMetaType &type,
-                                                   const QString &expr) const
+                                                   const QString &expr,
+                                                   const AbstractMetaClassCPtr &klass) const
 {
     // QFlags construct from integers, do not fix that
     if (isIntegerConstant(expr))
         return expr;
 
+    const QString field = qualifyStaticField(klass, expr);
+    if (!field.isEmpty())
+        return field;
+
     const auto typeEntry = type.typeEntry();
     EnumTypeEntryCPtr enumTypeEntry;
     FlagsTypeEntryCPtr flagsTypeEntry;
     if (typeEntry->isFlags()) {
-        flagsTypeEntry = qSharedPointerCast<const FlagsTypeEntry>(typeEntry);
+        flagsTypeEntry = std::static_pointer_cast<const FlagsTypeEntry>(typeEntry);
         enumTypeEntry = flagsTypeEntry->originator();
     } else {
         Q_ASSERT(typeEntry->isEnum());
-        enumTypeEntry = qSharedPointerCast<const EnumTypeEntry>(typeEntry);
+        enumTypeEntry = std::static_pointer_cast<const EnumTypeEntry>(typeEntry);
     }
     // Use the enum's qualified name (would otherwise be "QFlags<Enum>")
     if (!enumTypeEntry->qualifiedCppName().contains(u"::"))
@@ -177,7 +182,7 @@ bool AbstractMetaBuilder::dontFixDefaultValue(QStringView expr)
         || isIntegerConstant(expr) || isFloatConstant(expr);
 }
 
-QString AbstractMetaBuilderPrivate::qualifyStaticField(const AbstractMetaClass *c,
+QString AbstractMetaBuilderPrivate::qualifyStaticField(const AbstractMetaClassCPtr &c,
                                                        QStringView field)
 {
     if (!c || c->fields().isEmpty())
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
index 5a6aee3a9..e65a4f176 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
@@ -17,19 +17,31 @@
 #include <QtCore/QFileInfo>
 #include <QtCore/QList>
 #include <QtCore/QMap>
+#include <QtCore/QMultiHash>
 #include <QtCore/QSet>
 
 #include <optional>
+#include <set>
 
 class TypeDatabase;
 
+struct RejectEntry
+{
+    AbstractMetaBuilder::RejectReason reason;
+    QString signature;
+    QString sortkey;
+    QString message;
+};
+
+bool operator<(const RejectEntry &re1, const RejectEntry &re2);
+
 class AbstractMetaBuilderPrivate
 {
 public:
     struct TypeClassEntry
     {
         AbstractMetaType type;
-        const AbstractMetaClass *klass;
+        AbstractMetaClassCPtr klass;
     };
 
     using TranslateTypeFlags = AbstractMetaBuilder::TranslateTypeFlags;
@@ -37,7 +49,6 @@ public:
     Q_DISABLE_COPY(AbstractMetaBuilderPrivate)
 
     AbstractMetaBuilderPrivate();
-    ~AbstractMetaBuilderPrivate();
 
     static FileModelItem buildDom(QByteArrayList arguments,
                                   bool addCompilerSupportArguments,
@@ -60,57 +71,66 @@ public:
 
     NamespaceModelItem currentScope() const { return m_scopes.constLast(); }
 
-    AbstractMetaClass *argumentToClass(const ArgumentModelItem &,
-                                       const AbstractMetaClass *currentClass);
+    AbstractMetaClassPtr argumentToClass(const ArgumentModelItem &,
+                                       const AbstractMetaClassCPtr &currentClass);
 
-    void addAbstractMetaClass(AbstractMetaClass *cls, const _CodeModelItem *item);
-    AbstractMetaClass *traverseTypeDef(const FileModelItem &dom,
+    void addAbstractMetaClass(const AbstractMetaClassPtr &cls, const _CodeModelItem *item);
+    AbstractMetaClassPtr traverseTypeDef(const FileModelItem &dom,
                                        const TypeDefModelItem &typeDef,
-                                       AbstractMetaClass *currentClass);
+                                       const AbstractMetaClassPtr &currentClass);
+    AbstractMetaClassPtr traverseTypeDefHelper(const FileModelItem &dom,
+                                               const TypeDefModelItem &typeDef,
+                                               const AbstractMetaClassPtr &currentClass);
     void traverseTypesystemTypedefs();
-    AbstractMetaClass *traverseClass(const FileModelItem &dom,
+    AbstractMetaClassPtr traverseClass(const FileModelItem &dom,
                                      const ClassModelItem &item,
-                                     AbstractMetaClass *currentClass);
-    void traverseScopeMembers(const ScopeModelItem &item, AbstractMetaClass *metaClass);
+                                     const AbstractMetaClassPtr &currentClass);
+    void traverseScopeMembers(const ScopeModelItem &item,
+                              const AbstractMetaClassPtr &metaClass);
     void traverseClassMembers(const ClassModelItem &scopeItem);
-    void traverseUsingMembers(AbstractMetaClass *metaClass);
+    void traverseUsingMembers(const AbstractMetaClassPtr &metaClass) const;
     void traverseNamespaceMembers(const NamespaceModelItem &scopeItem);
-    bool setupInheritance(AbstractMetaClass *metaClass);
-    AbstractMetaClass *traverseNamespace(const FileModelItem &dom,
+    bool setupInheritance(const AbstractMetaClassPtr &metaClass);
+    AbstractMetaClassPtr traverseNamespace(const FileModelItem &dom,
                                          const NamespaceModelItem &item);
     std::optional<AbstractMetaEnum> traverseEnum(const EnumModelItem &item,
-                                                 AbstractMetaClass *enclosing,
+                                                 const AbstractMetaClassPtr &enclosing,
                                                  const QSet<QString> &enumsDeclarations);
-    void traverseEnums(const ScopeModelItem &item, AbstractMetaClass *parent,
+    void traverseEnums(const ScopeModelItem &item, const AbstractMetaClassPtr &parent,
                        const QStringList &enumsDeclarations);
     AbstractMetaFunctionRawPtrList classFunctionList(const ScopeModelItem &scopeItem,
                                                      AbstractMetaClass::Attributes *constructorAttributes,
-                                                     AbstractMetaClass *currentClass);
-    void traverseFunctions(ScopeModelItem item, AbstractMetaClass *parent);
+                                                     const AbstractMetaClassPtr &currentClass);
+    void traverseFunctions(const ScopeModelItem& item,
+                           const AbstractMetaClassPtr &parent);
     static void applyFunctionModifications(AbstractMetaFunction *func);
-    void traverseFields(const ScopeModelItem &item, AbstractMetaClass *parent);
+    void traverseFields(const ScopeModelItem &item, const AbstractMetaClassPtr &parent);
     bool traverseStreamOperator(const FunctionModelItem &functionItem,
-                                AbstractMetaClass *currentClass);
+                                const AbstractMetaClassPtr &currentClass);
     void traverseOperatorFunction(const FunctionModelItem &item,
-                                  AbstractMetaClass *currentClass);
+                                  const AbstractMetaClassPtr &currentClass);
     AbstractMetaFunction *traverseAddedFunctionHelper(const AddedFunctionPtr &addedFunc,
-                                                      AbstractMetaClass *metaClass,
+                                                      const AbstractMetaClassPtr &metaClass,
                                                       QString *errorMessage);
     bool traverseAddedGlobalFunction(const AddedFunctionPtr &addedFunc,
                                      QString *errorMessage);
     bool traverseAddedMemberFunction(const AddedFunctionPtr &addedFunc,
-                                     AbstractMetaClass *metaClass,
+                                     const AbstractMetaClassPtr &metaClass,
                                      QString *errorMessage);
-    AbstractMetaFunction *traverseFunction(const FunctionModelItem &function,
-                                           AbstractMetaClass *currentClass);
+    void rejectFunction(const FunctionModelItem &functionItem,
+                        const AbstractMetaClassPtr &currentClass,
+                        AbstractMetaBuilder::RejectReason reason,
+                        const QString &rejectReason);
+        AbstractMetaFunction *traverseFunction(const FunctionModelItem &function,
+                                           const AbstractMetaClassPtr &currentClass);
     std::optional<AbstractMetaField> traverseField(const VariableModelItem &field,
-                                                   const AbstractMetaClass *cls);
-    void checkFunctionModifications();
+                                                   const AbstractMetaClassCPtr &cls);
+    void checkFunctionModifications() const;
     void registerHashFunction(const FunctionModelItem &functionItem,
-                              AbstractMetaClass *currentClass);
+                              const AbstractMetaClassPtr &currentClass);
     void registerToStringCapabilityIn(const NamespaceModelItem &namespaceItem);
     void registerToStringCapability(const FunctionModelItem &functionItem,
-                                    AbstractMetaClass *currentClass);
+                                    const AbstractMetaClassPtr &currentClass);
 
     /**
      *   A conversion operator function should not have its owner class as
@@ -124,50 +144,53 @@ public:
      */
     static void fixReturnTypeOfConversionOperator(AbstractMetaFunction *metaFunction);
 
-    void parseQ_Properties(AbstractMetaClass *metaClass, const QStringList &declarations);
-    void setupEquals(AbstractMetaClass *metaClass);
-    void setupComparable(AbstractMetaClass *metaClass);
-    void setupExternalConversion(const AbstractMetaClass *cls);
+    void parseQ_Properties(const AbstractMetaClassPtr &metaClass,
+                           const QStringList &declarations);
+    void setupEquals(const AbstractMetaClassPtr &metaClass);
+    void setupComparable(const AbstractMetaClassPtr &metaClass);
+    void setupExternalConversion(const AbstractMetaClassCPtr &cls);
 
     static bool isQualifiedCppIdentifier(QStringView e);
     QString fixDefaultValue(QString expr, const AbstractMetaType &type,
-                            const AbstractMetaClass *) const;
+                            const AbstractMetaClassCPtr &) const;
     QString fixSimpleDefaultValue(QStringView expr,
-                                  const AbstractMetaClass *klass) const;
+                                  const AbstractMetaClassCPtr &klass) const;
 
-    QString fixEnumDefault(const AbstractMetaType &type, const QString &expr) const;
+    QString fixEnumDefault(const AbstractMetaType &type, const QString &expr,
+                           const AbstractMetaClassCPtr &) const;
     /// Qualify a static field name for default value expressions
-    static QString qualifyStaticField(const AbstractMetaClass *c, QStringView field);
+    static QString qualifyStaticField(const AbstractMetaClassCPtr &c, QStringView field);
 
     std::optional<AbstractMetaType>
-        translateType(const TypeInfo &type, const AbstractMetaClass *currentClass,
+        translateType(const TypeInfo &type, const AbstractMetaClassCPtr &currentClass,
                       TranslateTypeFlags flags = {}, QString *errorMessage = nullptr);
     static std::optional<AbstractMetaType>
-        translateTypeStatic(const TypeInfo &type, const AbstractMetaClass *current,
+        translateTypeStatic(const TypeInfo &type, const AbstractMetaClassCPtr &current,
                             AbstractMetaBuilderPrivate *d = nullptr, TranslateTypeFlags flags = {},
                             QString *errorMessageIn = nullptr);
     static TypeEntryCList findTypeEntriesHelper(const QString &qualifiedName, const QString &name,
-                                                const AbstractMetaClass *currentClass = nullptr,
+                                                TranslateTypeFlags flags = {},
+                                                const AbstractMetaClassCPtr &currentClass = {},
                                                 AbstractMetaBuilderPrivate *d = nullptr);
     static TypeEntryCList findTypeEntries(const QString &qualifiedName, const QString &name,
-                                          const AbstractMetaClass *currentClass = nullptr,
+                                          TranslateTypeFlags flags = {},
+                                          const AbstractMetaClassCPtr &currentClass = {},
                                           AbstractMetaBuilderPrivate *d = nullptr,
                                           QString *errorMessage = nullptr);
 
     qint64 findOutValueFromString(const QString &stringValue, bool &ok);
 
-    AbstractMetaClass *findTemplateClass(const QString& name, const AbstractMetaClass *context,
-                                         TypeInfo *info = Q_NULLPTR,
+    AbstractMetaClassPtr findTemplateClass(const QString& name, const AbstractMetaClassCPtr &context,
+                                         TypeInfo *info = nullptr,
                                          ComplexTypeEntryPtr *baseContainerType = nullptr) const;
-    AbstractMetaClassCList getBaseClasses(const AbstractMetaClass *metaClass) const;
+    AbstractMetaClassCList getBaseClasses(const AbstractMetaClassCPtr &metaClass) const;
 
-    static bool inheritTemplate(AbstractMetaClass *subclass,
-                                const AbstractMetaClass *templateClass,
+    static bool inheritTemplate(const AbstractMetaClassPtr &subclass,
+                                const AbstractMetaClassCPtr &templateClass,
                                 const TypeInfo &info);
-    static bool inheritTemplate(AbstractMetaClass *subclass,
-                                const AbstractMetaClass *templateClass,
-                                const AbstractMetaTypeList &templateTypes,
-                                InheritTemplateFlags flags = {});
+    static bool inheritTemplate(const AbstractMetaClassPtr &subclass,
+                                const AbstractMetaClassCPtr &templateClass,
+                                const AbstractMetaTypeList &templateTypes);
 
     static AbstractMetaFunctionPtr
         inheritTemplateFunction(const AbstractMetaFunctionCPtr &function,
@@ -176,10 +199,10 @@ public:
     static AbstractMetaFunctionPtr
         inheritTemplateMember(const AbstractMetaFunctionCPtr &function,
                               const AbstractMetaTypeList &templateTypes,
-                              const AbstractMetaClass *templateClass,
-                              AbstractMetaClass *subclass);
+                              const AbstractMetaClassCPtr &templateClass,
+                              const AbstractMetaClassPtr &subclass);
 
-    static void inheritTemplateFunctions(AbstractMetaClass *subclass);
+    static void inheritTemplateFunctions(const AbstractMetaClassPtr &subclass);
     static std::optional<AbstractMetaType>
         inheritTemplateType(const AbstractMetaTypeList &templateTypes,
                             const AbstractMetaType &metaType);
@@ -191,26 +214,26 @@ public:
     void setInclude(const TypeEntryPtr &te, const QString &path) const;
     static void fixArgumentNames(AbstractMetaFunction *func, const FunctionModificationList &mods);
 
-    void fillAddedFunctions(AbstractMetaClass *metaClass);
-    const AbstractMetaClass *resolveTypeSystemTypeDef(const AbstractMetaType &t) const;
+    void fillAddedFunctions(const AbstractMetaClassPtr &metaClass);
+    AbstractMetaClassCPtr resolveTypeSystemTypeDef(const AbstractMetaType &t) const;
 
     void fixSmartPointers();
 
-    AbstractMetaBuilder *q;
+    AbstractMetaBuilder *q = nullptr;
     AbstractMetaClassList m_metaClasses;
     AbstractMetaClassList m_templates;
     AbstractMetaClassList m_smartPointers;
-    QHash<const _CodeModelItem *, AbstractMetaClass *> m_itemToClass;
-    QHash<const AbstractMetaClass *, const _CodeModelItem *> m_classToItem;
+    QHash<const _CodeModelItem *, AbstractMetaClassPtr > m_itemToClass;
+    QHash<AbstractMetaClassCPtr, const _CodeModelItem *> m_classToItem;
     AbstractMetaFunctionCList m_globalFunctions;
     AbstractMetaEnumList m_globalEnums;
 
-    using RejectMap = QMap<QString, AbstractMetaBuilder::RejectReason>;
+    using RejectSet = std::set<RejectEntry>;
 
-    RejectMap m_rejectedClasses;
-    RejectMap m_rejectedEnums;
-    RejectMap m_rejectedFunctions;
-    RejectMap m_rejectedFields;
+    RejectSet m_rejectedClasses;
+    RejectSet m_rejectedEnums;
+    RejectSet m_rejectedFunctions;
+    RejectSet m_rejectedFields;
 
     QHash<TypeEntryCPtr, AbstractMetaEnum> m_enums;
 
@@ -220,6 +243,7 @@ public:
     QFileInfoList m_globalHeaders;
     QStringList m_headerPaths;
     mutable QHash<QString, Include> m_resolveIncludeHash;
+    QMultiHash<QString, QString> m_typedefTargetToName;
     QList<TypeClassEntry> m_typeSystemTypeDefs; // look up metatype->class for type system typedefs
     ApiExtractorFlags m_apiExtractorFlags;
     bool m_skipDeprecated = false;
diff --git a/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp b/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp
index e44d4ef7e..780170c22 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp
@@ -32,8 +32,8 @@ AbstractMetaEnumValue::AbstractMetaEnumValue() :
 
 AbstractMetaEnumValue::AbstractMetaEnumValue(const AbstractMetaEnumValue &) = default;
 AbstractMetaEnumValue &AbstractMetaEnumValue::operator=(const AbstractMetaEnumValue &) = default;
-AbstractMetaEnumValue::AbstractMetaEnumValue(AbstractMetaEnumValue &&) = default;
-AbstractMetaEnumValue &AbstractMetaEnumValue::operator=(AbstractMetaEnumValue &&) = default;
+AbstractMetaEnumValue::AbstractMetaEnumValue(AbstractMetaEnumValue &&) noexcept = default;
+AbstractMetaEnumValue &AbstractMetaEnumValue::operator=(AbstractMetaEnumValue &&) noexcept = default;
 AbstractMetaEnumValue::~AbstractMetaEnumValue() = default;
 
 EnumValue AbstractMetaEnumValue::value() const
@@ -101,10 +101,14 @@ public:
     {
     }
 
+    int unsignedUsedBits() const;
+    int signedUsedBits() const;
+
     AbstractMetaEnumValueList m_enumValues;
 
-    EnumTypeEntryPtr m_typeEntry;
+    EnumTypeEntryCPtr m_typeEntry;
     Documentation m_doc;
+    QString m_underlyingType;
 
     EnumKind m_enumKind = CEnum;
     Access m_access = Access::Public;
@@ -113,14 +117,46 @@ public:
     uint m_signed : 1;
 };
 
+static int _usedBits(uint64_t v)
+{
+    return (v >> 32) ? 64 : (v >> 16) ? 32 : (v >> 8) ? 16 : 8;
+}
+
+static int _usedBits(int64_t v)
+{
+    return (v >> 31) ? 64 : (v >> 15) ? 32 : (v >> 7) ? 16 : 8;
+}
+
+int AbstractMetaEnumData::unsignedUsedBits() const
+{
+    uint64_t maxValue = 0;
+    for (const auto &v : m_enumValues) {
+        if (const auto uv = v.value().unsignedValue(); uv > maxValue)
+            maxValue = uv;
+    }
+    return _usedBits(maxValue);
+}
+
+int AbstractMetaEnumData::signedUsedBits() const
+{
+    int64_t maxValue = 0;
+    for (const auto &v : m_enumValues) {
+        const auto sv = v.value().value();
+        const auto absV = sv < 0 ? ~sv : sv;
+        if (absV > maxValue)
+            maxValue = absV;
+    }
+    return _usedBits(maxValue);
+}
+
 AbstractMetaEnum::AbstractMetaEnum() : d(new AbstractMetaEnumData)
 {
 }
 
 AbstractMetaEnum::AbstractMetaEnum(const AbstractMetaEnum &) = default;
 AbstractMetaEnum &AbstractMetaEnum::operator=(const AbstractMetaEnum&) = default;
-AbstractMetaEnum::AbstractMetaEnum(AbstractMetaEnum &&) = default;
-AbstractMetaEnum &AbstractMetaEnum::operator=(AbstractMetaEnum &&) = default;
+AbstractMetaEnum::AbstractMetaEnum(AbstractMetaEnum &&) noexcept = default;
+AbstractMetaEnum &AbstractMetaEnum::operator=(AbstractMetaEnum &&) noexcept = default;
 AbstractMetaEnum::~AbstractMetaEnum() = default;
 
 const AbstractMetaEnumValueList &AbstractMetaEnum::values() const
@@ -128,6 +164,16 @@ const AbstractMetaEnumValueList &AbstractMetaEnum::values() const
     return d->m_enumValues;
 }
 
+AbstractMetaEnumValueList AbstractMetaEnum::nonRejectedValues() const
+{
+    auto te = d->m_typeEntry;
+    AbstractMetaEnumValueList result = d->m_enumValues;
+    auto pred = [te](const AbstractMetaEnumValue &v) {
+                    return te->isEnumValueRejected(v.name()); };
+    result.erase(std::remove_if(result.begin(), result.end(), pred), result.end());
+    return result;
+}
+
 void AbstractMetaEnum::addEnumValue(const AbstractMetaEnumValue &enumValue)
 {
     d->m_enumValues << enumValue;
@@ -263,12 +309,12 @@ void AbstractMetaEnum::setHasQEnumsDeclaration(bool on)
         d->m_hasQenumsDeclaration = on;
 }
 
-EnumTypeEntryPtr AbstractMetaEnum::typeEntry() const
+EnumTypeEntryCPtr AbstractMetaEnum::typeEntry() const
 {
     return d->m_typeEntry;
 }
 
-void AbstractMetaEnum::setTypeEntry(const EnumTypeEntryPtr &entry)
+void AbstractMetaEnum::setTypeEntry(const EnumTypeEntryCPtr &entry)
 {
     if (d->m_typeEntry != entry)
         d->m_typeEntry = entry;
@@ -285,12 +331,37 @@ void AbstractMetaEnum::setSigned(bool s)
         d->m_signed = s;
 }
 
+QString AbstractMetaEnum::underlyingType() const
+{
+    return d->m_underlyingType;
+}
+
+void AbstractMetaEnum::setUnderlyingType(const QString &underlyingType)
+{
+    if (d->m_underlyingType != underlyingType)
+        d->m_underlyingType = underlyingType;
+}
+
+int AbstractMetaEnum::usedBits() const
+{
+    return isSigned() ? d->signedUsedBits() : d->unsignedUsedBits();
+}
+
+QString AbstractMetaEnum::intTypeForSize(int usedBits, bool isSigned)
+{
+    QString result = u"int"_s + QString::number(usedBits) + u"_t"_s;
+    return isSigned ? result : u'u' + result;
+}
+
 #ifndef QT_NO_DEBUG_STREAM
 
-static void formatMetaEnumValue(QDebug &d, const AbstractMetaEnumValue &v)
+static void formatMetaEnumValue(QDebug &d, const AbstractMetaEnumValue &v, bool forceHex = false)
 {
     d << v.name() << '=';
-    v.value().formatDebug(d);
+    if (forceHex)
+        v.value().formatDebugHex(d);
+    else
+        v.value().formatDebug(d);
     if (v.isDeprecated())
         d << " (deprecated)";
 }
@@ -308,17 +379,19 @@ QDebug operator<<(QDebug d, const AbstractMetaEnumValue &v)
 
 static void formatMetaEnum(QDebug &d, const AbstractMetaEnum &e)
 {
-    d << e.fullName();
+    d << '"' << e.fullName() << '"';
     if (e.isDeprecated())
-        d << " (deprecated) ";
+        d << " (deprecated)";
+    d << " \"" << e.underlyingType() << '"';
     if (!e.isSigned())
-        d << " (unsigned) ";
-    d << '[';
+        d << " (unsigned)";
+    d << " [";
     const AbstractMetaEnumValueList &values = e.values();
+    const bool hasFlags = e.typeEntry()->flags() != nullptr;
     for (qsizetype i = 0, count = values.size(); i < count; ++i) {
         if (i)
             d << ", ";
-        formatMetaEnumValue(d, values.at(i));
+        formatMetaEnumValue(d, values.at(i), hasFlags);
     }
     d << ']';
 }
diff --git a/sources/shiboken6/ApiExtractor/abstractmetaenum.h b/sources/shiboken6/ApiExtractor/abstractmetaenum.h
index 0e356c1aa..03d7a3082 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetaenum.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetaenum.h
@@ -28,8 +28,8 @@ public:
     AbstractMetaEnumValue();
     AbstractMetaEnumValue(const AbstractMetaEnumValue &);
     AbstractMetaEnumValue &operator=(const AbstractMetaEnumValue &);
-    AbstractMetaEnumValue(AbstractMetaEnumValue &&);
-    AbstractMetaEnumValue &operator=(AbstractMetaEnumValue &&);
+    AbstractMetaEnumValue(AbstractMetaEnumValue &&) noexcept;
+    AbstractMetaEnumValue &operator=(AbstractMetaEnumValue &&) noexcept;
     ~AbstractMetaEnumValue();
 
     EnumValue value() const;
@@ -47,6 +47,8 @@ public:
     Documentation documentation() const;
     void setDocumentation(const Documentation& doc);
 
+    int usedBits() const;
+
 private:
     QSharedDataPointer<AbstractMetaEnumValueData> d;
 };
@@ -57,11 +59,12 @@ public:
     AbstractMetaEnum();
     AbstractMetaEnum(const AbstractMetaEnum &);
     AbstractMetaEnum &operator=(const AbstractMetaEnum &);
-    AbstractMetaEnum(AbstractMetaEnum &&);
-    AbstractMetaEnum &operator=(AbstractMetaEnum &&);
+    AbstractMetaEnum(AbstractMetaEnum &&) noexcept;
+    AbstractMetaEnum &operator=(AbstractMetaEnum &&) noexcept;
     ~AbstractMetaEnum();
 
     const AbstractMetaEnumValueList &values() const;
+    AbstractMetaEnumValueList nonRejectedValues() const;
     void addEnumValue(const AbstractMetaEnumValue &enumValue);
 
     std::optional<AbstractMetaEnumValue> findEnumValue(QStringView value) const;
@@ -97,12 +100,18 @@ public:
     bool hasQEnumsDeclaration() const;
     void setHasQEnumsDeclaration(bool on);
 
-    EnumTypeEntryPtr typeEntry() const;
-    void setTypeEntry(const EnumTypeEntryPtr &entry);
+    EnumTypeEntryCPtr typeEntry() const;
+    void setTypeEntry(const EnumTypeEntryCPtr &entry);
 
     bool isSigned() const;
     void setSigned(bool s);
 
+    QString underlyingType() const;
+    void setUnderlyingType(const QString &underlyingType);
+
+    static QString intTypeForSize(int usedBits, bool isSigned);
+    int usedBits() const;
+
 private:
     QSharedDataPointer<AbstractMetaEnumData> d;
 };
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafield.cpp b/sources/shiboken6/ApiExtractor/abstractmetafield.cpp
index 06bdbee1e..27a76d04d 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafield.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetafield.cpp
@@ -36,8 +36,8 @@ AbstractMetaField::AbstractMetaField() : d(new AbstractMetaFieldData)
 
 AbstractMetaField::AbstractMetaField(const AbstractMetaField &) = default;
 AbstractMetaField &AbstractMetaField::operator=(const AbstractMetaField &) = default;
-AbstractMetaField::AbstractMetaField(AbstractMetaField &&) = default;
-AbstractMetaField &AbstractMetaField::operator=(AbstractMetaField &&) = default;
+AbstractMetaField::AbstractMetaField(AbstractMetaField &&) noexcept = default;
+AbstractMetaField &AbstractMetaField::operator=(AbstractMetaField &&) noexcept = default;
 AbstractMetaField::~AbstractMetaField() = default;
 
 //    returned->setEnclosingClass(nullptr);
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafield.h b/sources/shiboken6/ApiExtractor/abstractmetafield.h
index 7de1298f3..0fa858791 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafield.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetafield.h
@@ -26,8 +26,8 @@ public:
     AbstractMetaField();
     AbstractMetaField(const AbstractMetaField &);
     AbstractMetaField &operator=(const AbstractMetaField &);
-    AbstractMetaField(AbstractMetaField &&);
-    AbstractMetaField &operator=(AbstractMetaField &&);
+    AbstractMetaField(AbstractMetaField &&) noexcept;
+    AbstractMetaField &operator=(AbstractMetaField &&) noexcept;
     ~AbstractMetaField();
 
     FieldModificationList modifications() const;
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
index 03e795ec2..11a02f154 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
@@ -18,6 +18,7 @@
 #include "sourcelocation.h"
 #include "typedatabase.h"
 #include "complextypeentry.h"
+#include "containertypeentry.h"
 #include "functiontypeentry.h"
 #include "primitivetypeentry.h"
 #include "typesystemtypeentry.h"
@@ -27,13 +28,15 @@
 #include <QtCore/QDebug>
 #include <QtCore/QRegularExpression>
 
+#include <algorithm>
+
 using namespace Qt::StringLiterals;
 
 // Cache FunctionModificationList in a flat list per class (0 for global
 // functions, or typically owner/implementing/declaring class.
 struct ModificationCacheEntry
 {
-     const AbstractMetaClass *klass;
+     AbstractMetaClassCPtr klass;
      FunctionModificationList modifications;
 };
 
@@ -45,7 +48,6 @@ public:
     AbstractMetaFunctionPrivate()
         : m_constant(false),
           m_reverse(false),
-          m_explicit(false),
           m_pointerOperator(false),
           m_isCallOperator(false)
     {
@@ -58,7 +60,7 @@ public:
     int overloadNumber(const AbstractMetaFunction *q) const;
 
     const FunctionModificationList &modifications(const AbstractMetaFunction *q,
-                                                  const AbstractMetaClass *implementor) const;
+                                                  const AbstractMetaClassCPtr &implementor) const;
 
     bool applyTypeModification(const AbstractMetaFunction *q,
                                const QString &type, int number, QString *errorMessage);
@@ -75,19 +77,19 @@ public:
     AbstractMetaFunction::FunctionType m_functionType = AbstractMetaFunction::NormalFunction;
     AbstractMetaType m_type;
     QString m_modifiedTypeName;
-    const AbstractMetaClass *m_class = nullptr;
-    const AbstractMetaClass *m_implementingClass = nullptr;
-    const AbstractMetaClass *m_declaringClass = nullptr;
+    AbstractMetaClassCPtr m_class;
+    AbstractMetaClassCPtr m_implementingClass;
+    AbstractMetaClassCPtr m_declaringClass;
     mutable ModificationCache m_modificationCache;
     int m_propertySpecIndex = -1;
     AbstractMetaArgumentList m_arguments;
     AddedFunctionPtr m_addedFunction;
     SourceLocation m_sourceLocation;
     AbstractMetaFunction::Attributes m_attributes;
+    FunctionAttributes m_cppAttributes;
     AbstractMetaFunction::Flags m_flags;
     uint m_constant                 : 1;
     uint m_reverse                  : 1;
-    uint m_explicit                 : 1;
     uint m_pointerOperator          : 1;
     uint m_isCallOperator           : 1;
     mutable int m_cachedOverloadNumber = TypeSystem::OverloadNumberUnset;
@@ -117,9 +119,9 @@ AbstractMetaFunction::AbstractMetaFunction(const AddedFunctionPtr &addedFunc) :
         setAccess(Access::Public);
         break;
     }
-    AbstractMetaFunction::Attributes atts = AbstractMetaFunction::FinalInTargetLang;
+    AbstractMetaFunction::Attributes atts;
     if (addedFunc->isStatic())
-        atts |= AbstractMetaFunction::Static;
+        setCppAttribute(FunctionAttribute::Static);
     if (addedFunc->isClassMethod())
         atts |= AbstractMetaFunction::ClassMethod;
     setAttributes(atts);
@@ -212,12 +214,12 @@ void AbstractMetaFunction::setPointerOperator(bool value)
 
 bool AbstractMetaFunction::isExplicit() const
 {
-    return d->m_explicit;
+    return d->m_cppAttributes.testFlag(FunctionAttribute::Explicit);
 }
 
 void AbstractMetaFunction::setExplicit(bool isExplicit)
 {
-    d->m_explicit = isExplicit;
+    d->m_cppAttributes.setFlag(FunctionAttribute::Explicit, isExplicit);
 }
 
 bool AbstractMetaFunction::returnsBool() const
@@ -259,6 +261,21 @@ void AbstractMetaFunction::operator-=(AbstractMetaFunction::Attribute attribute)
     d->m_attributes.setFlag(attribute, false);
 }
 
+FunctionAttributes AbstractMetaFunction::cppAttributes() const
+{
+    return d->m_cppAttributes;
+}
+
+void AbstractMetaFunction::setCppAttributes(FunctionAttributes a)
+{
+    d->m_cppAttributes = a;
+}
+
+void AbstractMetaFunction::setCppAttribute(FunctionAttribute a, bool on)
+{
+    d->m_cppAttributes.setFlag(a, on);
+}
+
 AbstractMetaFunction::Flags AbstractMetaFunction::flags() const
 {
     return d->m_flags;
@@ -272,9 +289,9 @@ void AbstractMetaFunction::setFlags(Flags f)
 /*******************************************************************************
  * Indicates that this function has a modification that removes it
  */
-bool AbstractMetaFunction::isModifiedRemoved(const AbstractMetaClass *cls) const
+bool AbstractMetaFunction::isModifiedRemoved(AbstractMetaClassCPtr cls) const
 {
-    if (!isInGlobalScope() && cls == nullptr)
+    if (!isInGlobalScope() && !cls)
         cls = d->m_implementingClass;
     for (const auto &mod : modifications(cls)) {
         if (mod.isRemoved())
@@ -284,7 +301,7 @@ bool AbstractMetaFunction::isModifiedRemoved(const AbstractMetaClass *cls) const
     return false;
 }
 
-bool AbstractMetaFunction::isModifiedFinal(const AbstractMetaClass *cls) const
+bool AbstractMetaFunction::isModifiedFinal(AbstractMetaClassCPtr cls) const
 {
     if (!isInGlobalScope() && cls == nullptr)
         cls = d->m_implementingClass;
@@ -310,12 +327,12 @@ void AbstractMetaFunction::setType(const AbstractMetaType &type)
     d->m_type = type;
 }
 
-const AbstractMetaClass *AbstractMetaFunction::ownerClass() const
+AbstractMetaClassCPtr AbstractMetaFunction::ownerClass() const
 {
     return d->m_class;
 }
 
-void AbstractMetaFunction::setOwnerClass(const AbstractMetaClass *cls)
+void AbstractMetaFunction::setOwnerClass(const AbstractMetaClassCPtr &cls)
 {
     d->m_class = cls;
 }
@@ -339,7 +356,7 @@ AbstractMetaFunction::CompareResult AbstractMetaFunction::compareTo(const Abstra
         result |= EqualImplementor;
 
     // Attributes
-    if (attributes() == other->attributes())
+    if (attributes() == other->attributes() && cppAttributes() == other->cppAttributes())
         result |= EqualAttributes;
 
     // Compare types
@@ -424,6 +441,10 @@ AbstractMetaFunction *AbstractMetaFunction::copy() const
 {
     auto *cpy = new AbstractMetaFunction;
     cpy->setAttributes(attributes());
+    auto ca = cppAttributes();
+    // Historical bug: explicit was not copied! (causing nontypetemplate_test.py fail)
+    ca.setFlag(FunctionAttribute::Explicit, false);
+    cpy->setCppAttributes(ca);
     cpy->setFlags(flags());
     cpy->setAccess(access());
     cpy->setName(name());
@@ -461,6 +482,9 @@ bool AbstractMetaFunction::generateBinding() const
 {
     switch (d->m_functionType) {
     case ConversionOperator:
+        if (d->m_name != u"operator int" && d->m_name != u"operator double")
+            return false;
+        break;
     case AssignmentOperatorFunction:
     case MoveAssignmentOperatorFunction:
     case AbstractMetaFunction::MoveConstructorFunction:
@@ -470,9 +494,19 @@ bool AbstractMetaFunction::generateBinding() const
             return false;
         break;
     }
+    // Can we access the wrapper in case of a protected method? If not,
+    // disable for consistency regardless of avoidProtectedHack.
+    if (isProtected()) {
+        const auto typeFlags = ownerClass()->typeEntry()->typeFlags();
+        if (typeFlags.testFlag(ComplexTypeEntry::DisableWrapper))
+            return false;
+    }
     if (isPrivate() && d->m_functionType != EmptyFunction)
         return false;
-    return d->m_name != u"qt_metacall" && !usesRValueReferences()
+    // RValue references only for user-specified
+    // functions (<add-function>/<declare-function>/<function>)
+    return d->m_name != u"qt_metacall" &&
+           (!usesRValueReferences() || d->m_addedFunction || d->m_typeEntry)
            && !isModifiedRemoved();
 }
 
@@ -482,7 +516,7 @@ bool AbstractMetaFunction::isWhiteListed() const
     case NormalFunction:
     case SignalFunction:
     case SlotFunction:
-        if (auto *dc = declaringClass()) {
+        if (auto dc = declaringClass()) {
             const QSet<QString> &whiteList = dc->typeEntry()->generateFunctions();
             return whiteList.isEmpty() || whiteList.contains(d->m_name)
                    || whiteList.contains(minimalSignature());
@@ -555,12 +589,17 @@ void AbstractMetaFunction::setConstant(bool constant)
 
 bool AbstractMetaFunction::isUserAdded() const
 {
-    return !d->m_addedFunction.isNull() && !d->m_addedFunction->isDeclaration();
+    return d->m_addedFunction && !d->m_addedFunction->isDeclaration();
+}
+
+bool AbstractMetaFunction::isUserAddedPythonOverride() const
+{
+    return d->m_addedFunction && d->m_addedFunction->isPythonOverride();
 }
 
 bool AbstractMetaFunction::isUserDeclared() const
 {
-    return !d->m_addedFunction.isNull() && d->m_addedFunction->isDeclaration();
+    return d->m_addedFunction && d->m_addedFunction->isDeclaration();
 }
 
 int AbstractMetaFunction::actualMinimumArgumentCount() const
@@ -590,7 +629,7 @@ int AbstractMetaFunction::actualArgumentIndex(int index) const
 }
 
 // Returns reference counts for argument at idx, or all arguments if idx == -2
-QList<ReferenceCount> AbstractMetaFunction::referenceCounts(const AbstractMetaClass *cls, int idx) const
+QList<ReferenceCount> AbstractMetaFunction::referenceCounts(const AbstractMetaClassCPtr &cls, int idx) const
 {
     QList<ReferenceCount> returned;
 
@@ -605,7 +644,7 @@ QList<ReferenceCount> AbstractMetaFunction::referenceCounts(const AbstractMetaCl
     return returned;
 }
 
-ArgumentOwner AbstractMetaFunction::argumentOwner(const AbstractMetaClass *cls, int idx) const
+ArgumentOwner AbstractMetaFunction::argumentOwner(const AbstractMetaClassCPtr &cls, int idx) const
 {
     for (const auto &mod : modifications(cls)) {
         for (const ArgumentModification &argumentMod : mod.argument_mods()) {
@@ -654,28 +693,28 @@ bool AbstractMetaFunction::argumentRemoved(int key) const
     return false;
 }
 
-const AbstractMetaClass *AbstractMetaFunction::targetLangOwner() const
+AbstractMetaClassCPtr AbstractMetaFunction::targetLangOwner() const
 {
     return d->m_class && d->m_class->isInvisibleNamespace()
         ?  d->m_class->targetLangEnclosingClass() : d->m_class;
 }
 
-const AbstractMetaClass *AbstractMetaFunction::declaringClass() const
+AbstractMetaClassCPtr AbstractMetaFunction::declaringClass() const
 {
     return d->m_declaringClass;
 }
 
-void AbstractMetaFunction::setDeclaringClass(const AbstractMetaClass *cls)
+void AbstractMetaFunction::setDeclaringClass(const AbstractMetaClassCPtr &cls)
 {
     d->m_declaringClass = cls;
 }
 
-const AbstractMetaClass *AbstractMetaFunction::implementingClass() const
+AbstractMetaClassCPtr AbstractMetaFunction::implementingClass() const
 {
     return d->m_implementingClass;
 }
 
-void AbstractMetaFunction::setImplementingClass(const AbstractMetaClass *cls)
+void AbstractMetaFunction::setImplementingClass(const AbstractMetaClassCPtr &cls)
 {
     d->m_implementingClass = cls;
 }
@@ -700,15 +739,23 @@ void AbstractMetaFunction::addArgument(const AbstractMetaArgument &argument)
     d->m_arguments << argument;
 }
 
+static bool modifiedDeprecated(const FunctionModification &mod)
+{
+    return mod.modifiers().testFlag(FunctionModification::Deprecated);
+}
+
+static bool modifiedUndeprecated(const FunctionModification &mod)
+{
+    return mod.modifiers().testFlag(FunctionModification::Undeprecated);
+}
+
 bool AbstractMetaFunction::isDeprecated() const
 {
-    if (d->m_attributes.testFlag(Attribute::Deprecated))
-        return true;
-    for (const auto &modification : modifications(declaringClass())) {
-        if (modification.isDeprecated())
-            return true;
-    }
-    return false;
+    const auto &mods = modifications(declaringClass());
+
+    return d->m_cppAttributes.testFlag(FunctionAttribute::Deprecated)
+           ? std::none_of(mods.cbegin(), mods.cend(), modifiedUndeprecated)
+           : std::any_of(mods.cbegin(), mods.cend(), modifiedDeprecated);
 }
 
 bool AbstractMetaFunction::isConstructor() const
@@ -799,12 +846,12 @@ void AbstractMetaFunction::setSourceLocation(const SourceLocation &sourceLocatio
     d->m_sourceLocation = sourceLocation;
 }
 
-static inline TypeSystem::AllowThread allowThreadMod(const AbstractMetaClass *klass)
+static inline TypeSystem::AllowThread allowThreadMod(const AbstractMetaClassCPtr &klass)
 {
     return klass->typeEntry()->allowThread();
 }
 
-static inline bool hasAllowThreadMod(const AbstractMetaClass *klass)
+static inline bool hasAllowThreadMod(const AbstractMetaClassCPtr &klass)
 {
     return allowThreadMod(klass) != TypeSystem::AllowThread::Unspecified;
 }
@@ -837,7 +884,7 @@ bool AbstractMetaFunction::allowThread() const
     return result;
 }
 
-TypeSystem::Ownership AbstractMetaFunction::argumentTargetOwnership(const AbstractMetaClass *cls, int idx) const
+TypeSystem::Ownership AbstractMetaFunction::argumentTargetOwnership(const AbstractMetaClassCPtr &cls, int idx) const
 {
     for (const auto &modification : modifications(cls)) {
         for (const ArgumentModification &argumentModification : modification.argument_mods()) {
@@ -856,10 +903,15 @@ const QString &AbstractMetaFunction::modifiedTypeName() const
 
 bool AbstractMetaFunction::generateOpaqueContainerReturn() const
 {
-    return isTypeModified()
-        && d->m_type.typeUsagePattern() == AbstractMetaType::ContainerPattern
-        && d->m_type.referenceType() == LValueReference
-        && d->m_type.generateOpaqueContainerForGetter(d->m_modifiedTypeName);
+    if (!isTypeModified() || d->m_type.typeUsagePattern() != AbstractMetaType::ContainerPattern)
+        return false;
+    // Needs to be a reference to a container, allow by value only for spans
+    if (d->m_type.referenceType() != LValueReference) {
+        auto cte = std::static_pointer_cast<const ContainerTypeEntry>(d->m_type.typeEntry());
+        if (cte->containerKind() != ContainerTypeEntry::SpanContainer)
+            return false;
+    }
+    return d->m_type.generateOpaqueContainerForGetter(d->m_modifiedTypeName);
 }
 
 bool AbstractMetaFunction::isModifiedToArray(int argumentIndex) const
@@ -947,12 +999,14 @@ QString AbstractMetaFunctionPrivate::formatMinimalSignature(const AbstractMetaFu
 {
     QString result = m_originalName + u'(';
     for (qsizetype i = 0; i < m_arguments.size(); ++i) {
+        const auto &argument = m_arguments.at(i);
         if (i > 0)
             result += u',';
 
-        result += comment
-            ? m_arguments.at(i).modifiedType().minimalSignature()
-            : m_arguments.at(i).type().minimalSignature();
+        const auto &type = comment ? argument.modifiedType() : argument.type();
+        result += type.minimalSignature();
+        if (comment && argument.hasDefaultValueExpression())
+            result += u'=';
     }
     result += u')';
     if (m_constant)
@@ -990,9 +1044,10 @@ QString AbstractMetaFunction::signatureComment() const
 QString AbstractMetaFunction::debugSignature() const
 {
     QString result;
-    const bool isOverride = attributes() & AbstractMetaFunction::OverriddenCppMethod;
-    const bool isFinal = attributes() & AbstractMetaFunction::FinalCppMethod;
-    if (!isOverride && !isFinal && (attributes() & AbstractMetaFunction::VirtualCppMethod))
+    const auto attributes = cppAttributes();
+    const bool isOverride = attributes.testFlag(FunctionAttribute::Override);
+    const bool isFinal = attributes.testFlag(FunctionAttribute::Final);
+    if (!isOverride && !isFinal && (attributes.testFlag(FunctionAttribute::Virtual)))
         result += u"virtual "_s;
     if (d->m_implementingClass)
         result += d->m_implementingClass->qualifiedCppName() + u"::"_s;
@@ -1005,7 +1060,7 @@ QString AbstractMetaFunction::debugSignature() const
 }
 
 FunctionModificationList AbstractMetaFunction::findClassModifications(const AbstractMetaFunction *f,
-                                                                      const AbstractMetaClass *implementor)
+                                                                      AbstractMetaClassCPtr implementor)
 {
     const auto signatures = f->modificationSignatures();
     FunctionModificationList mods;
@@ -1028,9 +1083,9 @@ FunctionModificationList AbstractMetaFunction::findGlobalModifications(const Abs
 
 const FunctionModificationList &
     AbstractMetaFunctionPrivate::modifications(const AbstractMetaFunction *q,
-                                               const AbstractMetaClass *implementor) const
+                                               const AbstractMetaClassCPtr &implementor) const
 {
-    if (!m_addedFunction.isNull())
+    if (m_addedFunction)
         return m_addedFunction->modifications();
     for (const auto &ce : m_modificationCache) {
         if (ce.klass == implementor)
@@ -1045,9 +1100,9 @@ const FunctionModificationList &
 }
 
 const FunctionModificationList &
-    AbstractMetaFunction::modifications(const AbstractMetaClass *implementor) const
+    AbstractMetaFunction::modifications(AbstractMetaClassCPtr implementor) const
 {
-    if (implementor == nullptr)
+    if (!implementor)
         implementor = d->m_class;
     return d->modifications(this, implementor);
 }
@@ -1059,13 +1114,13 @@ void AbstractMetaFunction::clearModificationsCache()
 
 const DocModificationList AbstractMetaFunction::addedFunctionDocModifications() const
 {
-    return d->m_addedFunction.isNull()
-           ? DocModificationList{} : d->m_addedFunction->docModifications();
+    return d->m_addedFunction
+        ? d->m_addedFunction->docModifications() : DocModificationList{};
 }
 
 QString AbstractMetaFunction::argumentName(int index,
                                            bool /* create */,
-                                           const AbstractMetaClass * /* implementor */) const
+                                           AbstractMetaClassCPtr  /* implementor */) const
 {
     return d->m_arguments[--index].name();
 }
@@ -1090,6 +1145,17 @@ void AbstractMetaFunction::setTypeEntry(const FunctionTypeEntryPtr &typeEntry)
     d->m_typeEntry = typeEntry;
 }
 
+QString AbstractMetaFunction::targetLangPackage() const
+{
+    if (d->m_addedFunction != nullptr)
+        return d->m_addedFunction->targetLangPackage();
+    if (d->m_class != nullptr)
+        return d->m_class->typeEntry()->targetLangPackage();
+    if (d->m_typeEntry != nullptr)
+        return d->m_typeEntry->targetLangPackage();
+    return {};
+}
+
 bool AbstractMetaFunction::isCallOperator() const
 {
     return d->m_name == u"operator()";
@@ -1186,12 +1252,12 @@ void AbstractMetaFunction::setExceptionSpecification(ExceptionSpecification e)
     d->m_exceptionSpecification = e;
 }
 
-static inline TypeSystem::ExceptionHandling exceptionMod(const AbstractMetaClass *klass)
+static inline TypeSystem::ExceptionHandling exceptionMod(const AbstractMetaClassCPtr &klass)
 {
     return klass->typeEntry()->exceptionHandling();
 }
 
-static inline bool hasExceptionMod(const AbstractMetaClass *klass)
+static inline bool hasExceptionMod(const AbstractMetaClassCPtr &klass)
 {
     return exceptionMod(klass) != TypeSystem::ExceptionHandling::Unspecified;
 }
@@ -1345,7 +1411,7 @@ bool AbstractMetaFunction::isInplaceOperator() const
 
 bool AbstractMetaFunction::isVirtual() const
 {
-    return d->m_attributes.testFlag(AbstractMetaFunction::VirtualCppMethod);
+    return d->m_cppAttributes.testFlag(FunctionAttribute::Virtual);
 }
 
 QString AbstractMetaFunctionPrivate::modifiedName(const AbstractMetaFunction *q) const
@@ -1370,7 +1436,7 @@ QString AbstractMetaFunction::modifiedName() const
 
 AbstractMetaFunctionCPtr
 AbstractMetaFunction::find(const AbstractMetaFunctionCList &haystack,
-                           QStringView needle)
+                           QAnyStringView needle)
 {
     for (const auto &f : haystack) {
         if (f->name() == needle)
@@ -1468,11 +1534,8 @@ TypeSystem::SnakeCase AbstractMetaFunction::snakeCase() const
             return mod.snakeCase();
     }
 
-    if (d->m_typeEntry) { // Global function
-        const auto snakeCase = d->m_typeEntry->snakeCase();
-        return snakeCase != TypeSystem::SnakeCase::Unspecified
-            ? snakeCase : typeSystemTypeEntry(d->m_typeEntry)->snakeCase();
-    }
+    if (d->m_typeEntry) // Global function
+        return typeSystemTypeEntry(d->m_typeEntry)->snakeCase();
 
     if (d->m_class) {
         auto typeEntry = d->m_class->typeEntry();
@@ -1492,7 +1555,7 @@ bool AbstractMetaFunction::injectedCodeUsesPySelf() const
 bool AbstractMetaFunction::injectedCodeCallsPythonOverride() const
 {
     static const QRegularExpression
-        overrideCallRegexCheck(QStringLiteral(R"(PyObject_Call\s*\(\s*%PYTHON_METHOD_OVERRIDE\s*,)"));
+        overrideCallRegexCheck(R"(PyObject_Call\s*\(\s*%PYTHON_METHOD_OVERRIDE\s*,)"_L1);
     Q_ASSERT(overrideCallRegexCheck.isValid());
     return injectedCodeContains(overrideCallRegexCheck, TypeSystem::CodeSnipPositionAny,
                                 TypeSystem::NativeCode);
@@ -1502,13 +1565,13 @@ bool AbstractMetaFunction::injectedCodeHasReturnValueAttribution(TypeSystem::Lan
 {
     if (language == TypeSystem::TargetLangCode) {
         static const QRegularExpression
-            retValAttributionRegexCheck_target(QStringLiteral(R"(%PYARG_0\s*=[^=]\s*.+)"));
+            retValAttributionRegexCheck_target(R"(%PYARG_0\s*=[^=]\s*.+)"_L1);
         Q_ASSERT(retValAttributionRegexCheck_target.isValid());
         return injectedCodeContains(retValAttributionRegexCheck_target, TypeSystem::CodeSnipPositionAny, language);
     }
 
     static const QRegularExpression
-        retValAttributionRegexCheck_native(QStringLiteral(R"(%0\s*=[^=]\s*.+)"));
+        retValAttributionRegexCheck_native(R"(%0\s*=[^=]\s*.+)"_L1);
     Q_ASSERT(retValAttributionRegexCheck_native.isValid());
     return injectedCodeContains(retValAttributionRegexCheck_native, TypeSystem::CodeSnipPositionAny, language);
 }
@@ -1606,9 +1669,9 @@ void AbstractMetaFunction::formatDebugVerbose(QDebug &debug) const
         debug << " [userAdded]";
     if (isUserDeclared())
         debug << " [userDeclared]";
-    if (d->m_explicit)
+    if (d->m_cppAttributes.testFlag(FunctionAttribute::Explicit))
         debug << " [explicit]";
-    if (attributes().testFlag(AbstractMetaFunction::Deprecated))
+    if (d->m_cppAttributes.testFlag(FunctionAttribute::Deprecated))
         debug << " [deprecated]";
     if (d->m_pointerOperator)
         debug << " [operator->]";
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.h b/sources/shiboken6/ApiExtractor/abstractmetafunction.h
index e1f8e774d..e252e439d 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafunction.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.h
@@ -11,6 +11,7 @@
 #include "typesystem_typedefs.h"
 #include "parser/codemodel_enums.h"
 
+#include <QtCore/QMetaObject>
 #include <QtCore/QScopedPointer>
 
 #include <optional>
@@ -31,6 +32,8 @@ class AbstractMetaFunction
 {
     Q_GADGET
 public:
+    Q_DISABLE_COPY_MOVE(AbstractMetaFunction)
+
     enum FunctionType {
         ConstructorFunction,
         CopyConstructorFunction,
@@ -89,14 +92,8 @@ public:
     enum Attribute {
         None                        = 0x00000000,
 
-        Friendly                    = 0x00000001,
-
-        Abstract                    = 0x00000002,
-        Static                      = 0x00000004,
         ClassMethod                 = 0x00000008,
 
-        FinalInTargetLang           = 0x00000010,
-
         GetterFunction              = 0x00000020,
         SetterFunction              = 0x00000040,
 
@@ -105,14 +102,8 @@ public:
         PropertyResetter            = 0x00000400,
         PropertyNotify              = 0x00000800,
 
-        Invokable                   = 0x00001000,
-
-        VirtualCppMethod            = 0x00010000,
-        OverriddenCppMethod         = 0x00020000,
-        FinalCppMethod              = 0x00040000,
         // Add by meta builder (implicit constructors, inherited methods, etc)
         AddedMethod                 = 0x001000000,
-        Deprecated                  = 0x002000000 // Code annotation
     };
     Q_DECLARE_FLAGS(Attributes, Attribute)
     Q_FLAG(Attribute)
@@ -123,6 +114,10 @@ public:
     void operator+=(Attribute attribute);
     void operator-=(Attribute attribute);
 
+    FunctionAttributes cppAttributes() const;
+    void setCppAttributes(FunctionAttributes a);
+    void setCppAttribute(FunctionAttribute a, bool on = true);
+
     enum class Flag { // Internal flags not relevant for comparing functions
         // Binary operator whose leading/trailing argument was removed by metabuilder
         OperatorLeadingClassArgumentRemoved = 0x1,
@@ -137,11 +132,9 @@ public:
     Flags flags() const;
     void setFlags(Flags f);
 
-    bool isFinalInTargetLang() const;
     bool isAbstract() const;
     bool isClassMethod() const;
     bool isStatic() const;
-    bool isInvokable() const;
     bool isPropertyReader() const;
     bool isPropertyWriter() const;
     bool isPropertyResetter() const;
@@ -241,8 +234,8 @@ public:
     QString signatureComment() const;
     QString debugSignature() const; // including virtual/override/final, etc., for debugging only.
 
-    bool isModifiedRemoved(const AbstractMetaClass *cls = nullptr) const;
-    bool isModifiedFinal(const AbstractMetaClass *cls = nullptr) const;
+    bool isModifiedRemoved(AbstractMetaClassCPtr cls = {}) const;
+    bool isModifiedFinal(AbstractMetaClassCPtr cls = {}) const;
 
     bool isVoid() const;
 
@@ -250,19 +243,19 @@ public:
     void setType(const AbstractMetaType &type);
 
     // The class that has this function as a member.
-    const AbstractMetaClass *ownerClass() const;
-    void setOwnerClass(const AbstractMetaClass *cls);
+    AbstractMetaClassCPtr ownerClass() const;
+    void setOwnerClass(const AbstractMetaClassCPtr &cls);
 
     // Owner excluding invisible namespaces
-    const AbstractMetaClass *targetLangOwner() const;
+    AbstractMetaClassCPtr targetLangOwner() const;
 
     // The first class in a hierarchy that declares the function
-    const AbstractMetaClass *declaringClass() const;
-    void setDeclaringClass(const AbstractMetaClass *cls);
+    AbstractMetaClassCPtr declaringClass() const;
+    void setDeclaringClass(const AbstractMetaClassCPtr &cls);
 
     // The class that actually implements this function
-    const AbstractMetaClass *implementingClass() const;
-    void setImplementingClass(const AbstractMetaClass *cls);
+    AbstractMetaClassCPtr implementingClass() const;
+    void setImplementingClass(const AbstractMetaClassCPtr &cls);
 
     const AbstractMetaArgumentList &arguments() const;
     AbstractMetaArgumentList &arguments();
@@ -307,6 +300,7 @@ public:
 
     /// Returns true if the AbstractMetaFunction was added by the user via the type system description.
     bool isUserAdded() const;
+    bool isUserAddedPythonOverride() const;
     /// Returns true if the AbstractMetaFunction was declared by the user via
     /// the type system description.
     bool isUserDeclared() const;
@@ -320,11 +314,13 @@ public:
 
     QString conversionRule(TypeSystem::Language language, int idx) const;
     bool hasConversionRule(TypeSystem::Language language, int idx) const;
-    QList<ReferenceCount> referenceCounts(const AbstractMetaClass *cls, int idx = -2) const;
-    ArgumentOwner argumentOwner(const AbstractMetaClass *cls, int idx) const;
+    QList<ReferenceCount>
+        referenceCounts(const AbstractMetaClassCPtr &cls, int idx = -2) const;
+    ArgumentOwner argumentOwner(const AbstractMetaClassCPtr &cls, int idx) const;
 
     // Returns the ownership rules for the given argument (target lang).
-    TypeSystem::Ownership argumentTargetOwnership(const AbstractMetaClass *cls, int idx) const;
+    TypeSystem::Ownership
+        argumentTargetOwnership(const AbstractMetaClassCPtr &cls, int idx) const;
 
     const QString &modifiedTypeName() const;
     bool isTypeModified() const { return !modifiedTypeName().isEmpty(); }
@@ -364,31 +360,32 @@ public:
     */
     bool hasSignatureModifications() const;
 
-    const FunctionModificationList &modifications(const AbstractMetaClass *implementor = nullptr) const;
+    const FunctionModificationList &modifications(AbstractMetaClassCPtr implementor = {}) const;
     void clearModificationsCache();
 
     const DocModificationList addedFunctionDocModifications() const;
 
     static FunctionModificationList findClassModifications(const AbstractMetaFunction *f,
-                                                           const AbstractMetaClass *implementor);
+                                                           AbstractMetaClassCPtr implementor);
     static FunctionModificationList findGlobalModifications(const AbstractMetaFunction *f);
 
     /**
      * Return the argument name if there is a modification the renamed value will be returned
      */
-    QString argumentName(int index, bool create = true, const AbstractMetaClass *cl = nullptr) const;
+    QString argumentName(int index, bool create = true, AbstractMetaClassCPtr cl = {}) const;
 
     int propertySpecIndex() const;
     void setPropertySpecIndex(int i);
 
     FunctionTypeEntryPtr typeEntry() const;
-
     void setTypeEntry(const FunctionTypeEntryPtr &typeEntry);
 
+    QString targetLangPackage() const;
+
     bool isCallOperator() const;
 
     static AbstractMetaFunctionCPtr
-        find(const AbstractMetaFunctionCList &haystack, QStringView needle);
+        find(const AbstractMetaFunctionCList &haystack, QAnyStringView needle);
 
     bool matches(OperatorQueryOptions) const;
 
@@ -447,19 +444,14 @@ private:
     QScopedPointer<AbstractMetaFunctionPrivate> d;
 };
 
-inline bool AbstractMetaFunction::isFinalInTargetLang() const
-{
-    return attributes().testFlag(FinalInTargetLang);
-}
-
 inline bool AbstractMetaFunction::isAbstract() const
 {
-    return attributes().testFlag(Abstract);
+    return cppAttributes().testFlag(FunctionAttribute::Abstract);
 }
 
 inline bool AbstractMetaFunction::isStatic() const
 {
-    return attributes().testFlag(Static);
+    return cppAttributes().testFlag(FunctionAttribute::Static);
 }
 
 inline bool AbstractMetaFunction::isClassMethod() const
@@ -467,11 +459,6 @@ inline bool AbstractMetaFunction::isClassMethod() const
     return attributes().testFlag(ClassMethod);
 }
 
-inline bool AbstractMetaFunction::isInvokable() const
-{
-    return attributes().testFlag(Invokable);
-}
-
 inline bool AbstractMetaFunction::isPropertyReader() const
 {
     return attributes().testFlag(PropertyReader);
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
index 77d346a9d..fb49cc9d0 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "abstractmetalang.h"
+#include "anystringview_helpers.h"
 #include "abstractmetalang_helpers.h"
 #include "abstractmetaargument.h"
 #include "abstractmetaenum.h"
@@ -60,13 +61,16 @@ public:
     static AbstractMetaFunction *
         createFunction(const QString &name, AbstractMetaFunction::FunctionType t,
                        Access access, const AbstractMetaArgumentList &arguments,
-                       const AbstractMetaType &returnType, AbstractMetaClass *q);
+                       const AbstractMetaType &returnType, const AbstractMetaClassPtr &q);
     void addConstructor(AbstractMetaFunction::FunctionType t,
                         Access access,
                         const AbstractMetaArgumentList &arguments,
-                        AbstractMetaClass *q);
-    void addUsingConstructors(AbstractMetaClass *q);
-    bool isUsingMember(const AbstractMetaClass *c, const QString &memberName,
+                        const AbstractMetaClassPtr &q);
+    void addUsingConstructors(const AbstractMetaClassPtr &q);
+    void sortFunctions();
+    void setFunctions(const AbstractMetaFunctionCList &functions,
+                      const AbstractMetaClassCPtr &q);
+    bool isUsingMember(const AbstractMetaClassCPtr &c, const QString &memberName,
                        Access minimumAccess) const;
     bool hasConstructors() const;
     qsizetype indexOfProperty(const QString &name) const;
@@ -90,14 +94,15 @@ public:
 
     Documentation m_doc;
 
-    const AbstractMetaClass *m_enclosingClass = nullptr;
-    const AbstractMetaClass *m_defaultSuperclass = nullptr;
+    AbstractMetaClassCPtr m_enclosingClass;
+    AbstractMetaClassCPtr m_defaultSuperclass;
     AbstractMetaClassCList m_baseClasses; // Real base classes after setting up inheritance
     AbstractMetaTypeList m_baseTemplateInstantiations;
-    const AbstractMetaClass *m_extendedNamespace = nullptr;
+    AbstractMetaClassCPtr m_extendedNamespace;
 
-    const AbstractMetaClass *m_templateBaseClass = nullptr;
+    AbstractMetaClassCPtr m_templateBaseClass;
     AbstractMetaFunctionCList m_functions;
+    AbstractMetaFunctionCList m_userAddedPythonOverrides;
     AbstractMetaFieldList m_fields;
     AbstractMetaEnumList m_enums;
     QList<QPropertySpec> m_propertySpecs;
@@ -173,29 +178,16 @@ AbstractMetaFunctionCList AbstractMetaClass::functionsInTargetLang() const
     FunctionQueryOptions default_flags = FunctionQueryOption::NormalFunctions
         | FunctionQueryOption::Visible | FunctionQueryOption::NotRemoved;
 
-    // Only public functions in final classes
-    // default_flags |= isFinal() ? WasPublic : 0;
-    FunctionQueryOptions public_flags;
-    if (isFinalInTargetLang())
-        public_flags |= FunctionQueryOption::WasPublic;
-
     // Constructors
     AbstractMetaFunctionCList returned = queryFunctions(FunctionQueryOption::AnyConstructor
-                                                        | default_flags | public_flags);
-
-    // Final functions
-    returned += queryFunctions(FunctionQueryOption::FinalInTargetLangFunctions
-                               | FunctionQueryOption::NonStaticFunctions
-                               | default_flags | public_flags);
+                                                        | default_flags);
 
-    // Virtual functions
-    returned += queryFunctions(FunctionQueryOption::VirtualInTargetLangFunctions
-                               | FunctionQueryOption::NonStaticFunctions
-                               | default_flags | public_flags);
+    returned += queryFunctions(FunctionQueryOption::NonStaticFunctions
+                               | default_flags);
 
     // Static functions
     returned += queryFunctions(FunctionQueryOption::StaticFunctions
-                               | default_flags | public_flags);
+                               | default_flags);
 
     // Empty, private functions, since they aren't caught by the other ones
     returned += queryFunctions(FunctionQueryOption::Empty | FunctionQueryOption::Invisible);
@@ -314,15 +306,15 @@ bool AbstractMetaClass::hasStaticFields() const
 
 void AbstractMetaClass::sortFunctions()
 {
-    std::sort(d->m_functions.begin(), d->m_functions.end(), function_sorter);
+   d->sortFunctions();
 }
 
-const AbstractMetaClass *AbstractMetaClass::templateBaseClass() const
+AbstractMetaClassCPtr AbstractMetaClass::templateBaseClass() const
 {
     return d->m_templateBaseClass;
 }
 
-void AbstractMetaClass::setTemplateBaseClass(const AbstractMetaClass *cls)
+void AbstractMetaClass::setTemplateBaseClass(const AbstractMetaClassCPtr &cls)
 {
     d->m_templateBaseClass = cls;
 }
@@ -332,17 +324,28 @@ const AbstractMetaFunctionCList &AbstractMetaClass::functions() const
     return d->m_functions;
 }
 
-void AbstractMetaClass::setFunctions(const AbstractMetaFunctionCList &functions)
+const AbstractMetaFunctionCList &AbstractMetaClass::userAddedPythonOverrides() const
+{
+    return d->m_userAddedPythonOverrides;
+}
+
+void AbstractMetaClassPrivate::sortFunctions()
+{
+    std::sort(m_functions.begin(), m_functions.end(), function_sorter);
+}
+
+void AbstractMetaClassPrivate::setFunctions(const AbstractMetaFunctionCList &functions,
+                                            const AbstractMetaClassCPtr &q)
 {
-    d->m_functions = functions;
+    m_functions = functions;
 
     // Functions must be sorted by name before next loop
     sortFunctions();
 
-    for (const auto &f : std::as_const(d->m_functions)) {
-        qSharedPointerConstCast<AbstractMetaFunction>(f)->setOwnerClass(this);
+    for (const auto &f : std::as_const(m_functions)) {
+        std::const_pointer_cast<AbstractMetaFunction>(f)->setOwnerClass(q);
         if (!f->isPublic())
-            d->m_hasNonpublic = true;
+            m_hasNonpublic = true;
     }
 }
 
@@ -379,20 +382,27 @@ void AbstractMetaClassPrivate::addFunction(const AbstractMetaFunctionCPtr &funct
         && function->functionType() == AbstractMetaFunction::ConstructorFunction;
 }
 
-void AbstractMetaClass::addFunction(const AbstractMetaFunctionCPtr &function)
+void AbstractMetaClass::addFunction(const AbstractMetaClassPtr &klass,
+                                    const AbstractMetaFunctionCPtr &function)
 {
-    auto nonConstF = qSharedPointerConstCast<AbstractMetaFunction>(function);
-    nonConstF->setOwnerClass(this);
+    auto nonConstF = std::const_pointer_cast<AbstractMetaFunction>(function);
+    nonConstF->setOwnerClass(klass);
 
     // Set the default value of the declaring class. This may be changed
     // in fixFunctions later on
-    nonConstF->setDeclaringClass(this);
+    nonConstF->setDeclaringClass(klass);
 
     // Some of the queries below depend on the implementing class being set
     // to function properly. Such as function modifications
-    nonConstF->setImplementingClass(this);
+    nonConstF->setImplementingClass(klass);
 
-    d->addFunction(function);
+    if (function->isUserAddedPythonOverride()) {
+        nonConstF->setConstant(false);
+        nonConstF->setCppAttribute(FunctionAttribute::Static);
+        klass->d->m_userAddedPythonOverrides.append(function);
+    } else {
+        klass->d->addFunction(function);
+    }
 }
 
 bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
@@ -430,17 +440,17 @@ QString AbstractMetaClass::baseClassName() const
 }
 
 // Attribute "default-superclass"
-const AbstractMetaClass *AbstractMetaClass::defaultSuperclass() const
+AbstractMetaClassCPtr AbstractMetaClass::defaultSuperclass() const
 {
     return d->m_defaultSuperclass;
 }
 
-void AbstractMetaClass::setDefaultSuperclass(AbstractMetaClass *s)
+void AbstractMetaClass::setDefaultSuperclass(const AbstractMetaClassPtr &s)
 {
     d->m_defaultSuperclass = s;
 }
 
-const AbstractMetaClass *AbstractMetaClass::baseClass() const
+AbstractMetaClassCPtr AbstractMetaClass::baseClass() const
 {
     return d->m_baseClasses.value(0, nullptr);
 }
@@ -455,7 +465,7 @@ const AbstractMetaClassCList &AbstractMetaClass::baseClasses() const
 AbstractMetaClassCList AbstractMetaClass::typeSystemBaseClasses() const
 {
     AbstractMetaClassCList result = d->m_baseClasses;
-    if (d->m_defaultSuperclass != nullptr) {
+    if (d->m_defaultSuperclass) {
         result.removeAll(d->m_defaultSuperclass);
         result.prepend(d->m_defaultSuperclass);
     }
@@ -467,21 +477,21 @@ AbstractMetaClassCList AbstractMetaClass::allTypeSystemAncestors() const
 {
     AbstractMetaClassCList result;
     const auto baseClasses = typeSystemBaseClasses();
-    for (auto *base : baseClasses) {
+    for (const auto &base : baseClasses) {
         result.append(base);
         result.append(base->allTypeSystemAncestors());
     }
     return result;
 }
 
-void AbstractMetaClass::addBaseClass(const AbstractMetaClass *baseClass)
+void AbstractMetaClass::addBaseClass(const AbstractMetaClassCPtr &baseClass)
 {
     Q_ASSERT(baseClass);
     d->m_baseClasses.append(baseClass);
     d->m_isPolymorphic |= baseClass->isPolymorphic();
 }
 
-void AbstractMetaClass::setBaseClass(const AbstractMetaClass *baseClass)
+void AbstractMetaClass::setBaseClass(const AbstractMetaClassCPtr &baseClass)
 {
     if (baseClass) {
         d->m_baseClasses.prepend(baseClass);
@@ -489,12 +499,12 @@ void AbstractMetaClass::setBaseClass(const AbstractMetaClass *baseClass)
     }
 }
 
-const AbstractMetaClass *AbstractMetaClass::extendedNamespace() const
+AbstractMetaClassCPtr AbstractMetaClass::extendedNamespace() const
 {
     return d->m_extendedNamespace;
 }
 
-void AbstractMetaClass::setExtendedNamespace(const AbstractMetaClass *e)
+void AbstractMetaClass::setExtendedNamespace(const AbstractMetaClassCPtr &e)
 {
     d->m_extendedNamespace = e;
 }
@@ -504,7 +514,7 @@ const AbstractMetaClassCList &AbstractMetaClass::innerClasses() const
     return d->m_innerClasses;
 }
 
-void AbstractMetaClass::addInnerClass(AbstractMetaClass *cl)
+void AbstractMetaClass::addInnerClass(const AbstractMetaClassPtr &cl)
 {
     d->m_innerClasses << cl;
 }
@@ -536,17 +546,12 @@ bool AbstractMetaClass::isInlineNamespace() const
 {
     bool result = false;
     if (d->m_typeEntry->isNamespace()) {
-        const auto nte = qSharedPointerCast<const NamespaceTypeEntry>(d->m_typeEntry);
+        const auto nte = std::static_pointer_cast<const NamespaceTypeEntry>(d->m_typeEntry);
         result = nte->isInlineNamespace();
     }
     return result;
 }
 
-bool AbstractMetaClass::isQObject() const
-{
-    return inheritsFrom(u"QObject"_s);
-}
-
 bool AbstractMetaClass::isQtNamespace() const
 {
     return isNamespace() && name() == u"Qt";
@@ -559,15 +564,15 @@ QString AbstractMetaClass::qualifiedCppName() const
 
 bool AbstractMetaClass::hasFunction(const QString &str) const
 {
-    return !findFunction(str).isNull();
+    return bool(findFunction(str));
 }
 
-AbstractMetaFunctionCPtr AbstractMetaClass::findFunction(QStringView functionName) const
+AbstractMetaFunctionCPtr AbstractMetaClass::findFunction(QAnyStringView functionName) const
 {
     return AbstractMetaFunction::find(d->m_functions, functionName);
 }
 
-AbstractMetaFunctionCList AbstractMetaClass::findFunctions(QStringView functionName) const
+AbstractMetaFunctionCList AbstractMetaClass::findFunctions(QAnyStringView functionName) const
 {
     AbstractMetaFunctionCList result;
     std::copy_if(d->m_functions.cbegin(), d->m_functions.cend(),
@@ -798,41 +803,40 @@ bool AbstractMetaClass::hasCopyConstructor() const
 bool AbstractMetaClass::hasPrivateCopyConstructor() const
 {
     const auto copyCt = copyConstructor();
-    return !copyCt.isNull() && copyCt->isPrivate();
+    return copyCt && copyCt->isPrivate();
 }
 
 void AbstractMetaClassPrivate::addConstructor(AbstractMetaFunction::FunctionType t,
                                               Access access,
                                               const AbstractMetaArgumentList &arguments,
-                                              AbstractMetaClass *q)
+                                              const AbstractMetaClassPtr &q)
 {
     auto *f = createFunction(q->name(), t, access, arguments, AbstractMetaType::createVoid(), q);
     if (access != Access::Private)
          m_hasNonPrivateConstructor = true;
-    f->setAttributes(AbstractMetaFunction::FinalInTargetLang
-                     | AbstractMetaFunction::AddedMethod);
+    f->setAttributes(AbstractMetaFunction::AddedMethod);
     addFunction(AbstractMetaFunctionCPtr(f));
 }
 
-void AbstractMetaClass::addDefaultConstructor()
+void AbstractMetaClass::addDefaultConstructor(const AbstractMetaClassPtr &klass)
 {
-    d->addConstructor(AbstractMetaFunction::ConstructorFunction,
-                      Access::Public, {}, this);
+    klass->d->addConstructor(AbstractMetaFunction::ConstructorFunction,
+                             Access::Public, {}, klass);
 }
 
-void AbstractMetaClass::addDefaultCopyConstructor()
+void AbstractMetaClass::addDefaultCopyConstructor(const AbstractMetaClassPtr &klass)
 {
-    AbstractMetaType argType(typeEntry());
+    AbstractMetaType argType(klass->typeEntry());
     argType.setReferenceType(LValueReference);
     argType.setConstant(true);
     argType.setTypeUsagePattern(AbstractMetaType::ValuePattern);
 
     AbstractMetaArgument arg;
     arg.setType(argType);
-    arg.setName(name());
+    arg.setName(klass->name());
 
-    d->addConstructor(AbstractMetaFunction::CopyConstructorFunction,
-                      Access::Public, {arg}, this);
+    klass->d->addConstructor(AbstractMetaFunction::CopyConstructorFunction,
+                             Access::Public, {arg}, klass);
 }
 
 AbstractMetaFunction *
@@ -841,7 +845,7 @@ AbstractMetaFunction *
                                             Access access,
                                             const AbstractMetaArgumentList &arguments,
                                             const AbstractMetaType &returnType,
-                                            AbstractMetaClass *q)
+                                            const AbstractMetaClassPtr &q)
 {
     auto *f = new AbstractMetaFunction(name);
     f->setType(returnType);
@@ -857,7 +861,7 @@ AbstractMetaFunction *
 static AbstractMetaType boolType()
 {
     auto boolType = TypeDatabase::instance()->findType(u"bool"_s);
-    Q_ASSERT(!boolType.isNull());
+    Q_ASSERT(boolType);
     AbstractMetaType result(boolType);
     result.decideUsagePattern();
     return result;
@@ -866,11 +870,11 @@ static AbstractMetaType boolType()
 // Helper to synthesize comparison operators from a spaceship operator. Since
 // shiboken also generates code for comparing to different types, this fits
 // better than of handling it in the generator code.
-void AbstractMetaClass::addSynthesizedComparisonOperators()
+void AbstractMetaClass::addSynthesizedComparisonOperators(const AbstractMetaClassPtr &c)
 {
     static const auto returnType = boolType();
 
-    AbstractMetaType selfType(typeEntry());
+    AbstractMetaType selfType(c->typeEntry());
     selfType.setConstant(true);
     selfType.setReferenceType(LValueReference);
     selfType.decideUsagePattern();
@@ -885,8 +889,8 @@ void AbstractMetaClass::addSynthesizedComparisonOperators()
         auto *f = AbstractMetaClassPrivate::createFunction(QLatin1StringView(op),
                                                            AbstractMetaFunction::ComparisonOperator,
                                                            Access::Public, arguments,
-                                                           returnType, this);
-        d->addFunction(AbstractMetaFunctionCPtr(f));
+                                                           returnType, c);
+         c->d->addFunction(AbstractMetaFunctionCPtr(f));
     }
 }
 
@@ -992,7 +996,7 @@ bool AbstractMetaClass::isImplicitlyDefaultConstructible() const
     return std::all_of(d->m_fields.cbegin(), d->m_fields.cend(),
                         defaultConstructibleField)
         && std::all_of(d->m_baseClasses.cbegin(), d->m_baseClasses.cend(),
-                       [] (const AbstractMetaClass *c) {
+                       [] (const AbstractMetaClassCPtr &c) {
                            return c->isDefaultConstructible();
                        });
 }
@@ -1027,7 +1031,7 @@ bool AbstractMetaClass::isImplicitlyCopyConstructible() const
 {
     // Fields are currently not considered
     return std::all_of(d->m_baseClasses.cbegin(), d->m_baseClasses.cend(),
-                       [] (const AbstractMetaClass *c) {
+                       [] (const AbstractMetaClassCPtr &c) {
                            return c->isCopyConstructible();
                        });
 }
@@ -1042,16 +1046,16 @@ bool AbstractMetaClass::canAddDefaultCopyConstructor() const
     return isImplicitlyCopyConstructible();
 }
 
-static bool classHasParentManagement(const AbstractMetaClass *c)
+static bool classHasParentManagement(const AbstractMetaClassCPtr &c)
 {
     const auto flags = c->typeEntry()->typeFlags();
     return flags.testFlag(ComplexTypeEntry::ParentManagement);
 }
 
-TypeEntryCPtr AbstractMetaClass::parentManagementEntry() const
+TypeEntryCPtr parentManagementEntry(const AbstractMetaClassCPtr &klass)
 {
-    if (isObjectType()) {
-        if (auto *c = recurseClassHierarchy(this, classHasParentManagement))
+    if (klass->typeEntry()->isObject()) {
+        if (auto c = recurseClassHierarchy(klass, classHasParentManagement))
             return c->typeEntry();
     }
     return nullptr;
@@ -1121,7 +1125,7 @@ void AbstractMetaClass::addUsingMember(const UsingMember &um)
     d->m_usingMembers.append(um);
 }
 
-bool AbstractMetaClassPrivate::isUsingMember(const AbstractMetaClass *c,
+bool AbstractMetaClassPrivate::isUsingMember(const AbstractMetaClassCPtr &c,
                                              const QString &memberName,
                                              Access minimumAccess) const
 {
@@ -1132,7 +1136,7 @@ bool AbstractMetaClassPrivate::isUsingMember(const AbstractMetaClass *c,
     return it != m_usingMembers.cend() && it->access >= minimumAccess;
 }
 
-bool AbstractMetaClass::isUsingMember(const AbstractMetaClass *c,
+bool AbstractMetaClass::isUsingMember(const AbstractMetaClassCPtr &c,
                                       const QString &memberName,
                                       Access minimumAccess) const
 {
@@ -1163,24 +1167,15 @@ bool AbstractMetaClass::queryFunction(const AbstractMetaFunction *f, FunctionQue
     if (query.testFlag(FunctionQueryOption::Visible) && f->isPrivate())
         return false;
 
-    if (query.testFlag(FunctionQueryOption::VirtualInTargetLangFunctions) && f->isFinalInTargetLang())
-        return false;
-
     if (query.testFlag(FunctionQueryOption::Invisible) && !f->isPrivate())
         return false;
 
     if (query.testFlag(FunctionQueryOption::Empty) && !f->isEmptyFunction())
         return false;
 
-    if (query.testFlag(FunctionQueryOption::WasPublic) && !f->wasPublic())
-        return false;
-
     if (query.testFlag(FunctionQueryOption::ClassImplements) && f->ownerClass() != f->implementingClass())
         return false;
 
-    if (query.testFlag(FunctionQueryOption::FinalInTargetLangFunctions) && !f->isFinalInTargetLang())
-        return false;
-
     if (query.testFlag(FunctionQueryOption::VirtualInCppFunctions) && !f->isVirtual())
         return false;
 
@@ -1244,7 +1239,7 @@ AbstractMetaFunctionCList AbstractMetaClass::queryFunctionList(const AbstractMet
 {
     AbstractMetaFunctionCList result;
     for (const auto &f : list) {
-        if (queryFunction(f.data(), query))
+        if (queryFunction(f.get(), query))
             result.append(f);
     }
     return result;
@@ -1254,7 +1249,7 @@ AbstractMetaFunctionCPtr AbstractMetaClass::queryFirstFunction(const AbstractMet
                                                                FunctionQueryOptions query)
 {
     for (const auto &f : list) {
-        if (queryFunction(f.data(), query))
+        if (queryFunction(f.get(), query))
             return f;
     }
     return {};
@@ -1344,7 +1339,7 @@ void AbstractMetaClass::getEnumsToBeGenerated(AbstractMetaEnumList *enumList) co
 void AbstractMetaClass::getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMetaEnumList *enumList) const
 {
     if (isNamespace()) {
-        invisibleNamespaceRecursion([enumList](const AbstractMetaClass *c) {
+        invisibleNamespaceRecursion([enumList](const AbstractMetaClassCPtr &c) {
             c->getEnumsToBeGenerated(enumList);
         });
     }
@@ -1353,7 +1348,7 @@ void AbstractMetaClass::getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMet
 void AbstractMetaClass::getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionCList *funcList) const
 {
     if (isNamespace()) {
-        invisibleNamespaceRecursion([funcList](const AbstractMetaClass *c) {
+        invisibleNamespaceRecursion([funcList](const AbstractMetaClassCPtr &c) {
             funcList->append(c->functions());
         });
     }
@@ -1364,7 +1359,8 @@ QString AbstractMetaClass::fullName() const
     return package() + u'.' + d->m_typeEntry->targetLangName();
 }
 
-static void addExtraIncludeForType(AbstractMetaClass *metaClass, const AbstractMetaType &type)
+static void addExtraIncludeForType(const AbstractMetaClassPtr &metaClass,
+                                   const AbstractMetaType &type)
 {
 
     Q_ASSERT(metaClass);
@@ -1381,7 +1377,7 @@ static void addExtraIncludeForType(AbstractMetaClass *metaClass, const AbstractM
     }
 }
 
-static void addExtraIncludesForFunction(AbstractMetaClass *metaClass,
+static void addExtraIncludesForFunction(const AbstractMetaClassPtr &metaClass,
                                         const AbstractMetaFunctionCPtr &meta_function)
 {
     Q_ASSERT(metaClass);
@@ -1416,7 +1412,7 @@ static bool addSuperFunction(const AbstractMetaFunctionCPtr &f)
 // Add constructors imported via "using" from the base classes. This is not
 // needed for normal hidden inherited member functions since we generate a
 // cast to the base class to call them into binding code.
-void AbstractMetaClassPrivate::addUsingConstructors(AbstractMetaClass *q)
+void AbstractMetaClassPrivate::addUsingConstructors(const AbstractMetaClassPtr &q)
 {
     // Restricted to the non-constructor case currently to avoid
     // having to compare the parameter lists of existing constructors.
@@ -1425,7 +1421,7 @@ void AbstractMetaClassPrivate::addUsingConstructors(AbstractMetaClass *q)
         return;
     }
 
-    for (auto superClass : m_baseClasses) {
+    for (const auto &superClass : m_baseClasses) {
         // Find any "using base-constructor" directives
         if (isUsingMember(superClass, superClass->name(), Access::Protected)) {
             // Add to derived class with parameter lists.
@@ -1440,41 +1436,51 @@ void AbstractMetaClassPrivate::addUsingConstructors(AbstractMetaClass *q)
     }
 }
 
-void AbstractMetaClass::fixFunctions()
+static inline bool isSignal(const AbstractMetaFunctionCPtr &f)
 {
+    return f->isSignal();
+}
+
+void AbstractMetaClass::fixFunctions(const AbstractMetaClassPtr &klass)
+{
+    auto *d = klass->d.data();
     if (d->m_functionsFixed)
         return;
 
     d->m_functionsFixed = true;
 
-    AbstractMetaFunctionCList funcs = functions();
+    AbstractMetaFunctionCList funcs = klass->functions();
     AbstractMetaFunctionCList nonRemovedFuncs;
     nonRemovedFuncs.reserve(funcs.size());
 
-    d->addUsingConstructors(this);
+    d->addUsingConstructors(klass);
 
     for (const auto &f : std::as_const(funcs)) {
         // Fishy: Setting up of implementing/declaring/base classes changes
         // the applicable modifications; clear cached ones.
-        qSharedPointerConstCast<AbstractMetaFunction>(f)->clearModificationsCache();
+        std::const_pointer_cast<AbstractMetaFunction>(f)->clearModificationsCache();
         if (!f->isModifiedRemoved())
             nonRemovedFuncs.append(f);
     }
 
-    for (auto *superClassC : d->m_baseClasses) {
-        auto *superClass = const_cast<AbstractMetaClass *>(superClassC);
-        superClass->fixFunctions();
+    for (const auto &superClassC : d->m_baseClasses) {
+        for (const auto &pof : superClassC->userAddedPythonOverrides()) {
+            auto *clonedPof = pof->copy();
+            clonedPof->setOwnerClass(klass);
+            d->m_userAddedPythonOverrides.append(AbstractMetaFunctionCPtr{clonedPof});
+        }
+
+        auto superClass = std::const_pointer_cast<AbstractMetaClass>(superClassC);
+        AbstractMetaClass::fixFunctions(superClass);
         // Since we always traverse the complete hierarchy we are only
         // interrested in what each super class implements, not what
         // we may have propagated from their base classes again.
         AbstractMetaFunctionCList superFuncs;
-        // Super classes can never be final
-        if (superClass->isFinalInTargetLang()) {
-            qCWarning(lcShiboken).noquote().nospace()
-                << "Final class '" << superClass->name() << "' set to non-final, as it is extended by other classes";
-            *superClass -= AbstractMetaClass::FinalInTargetLang;
-        }
         superFuncs = superClass->queryFunctions(FunctionQueryOption::ClassImplements);
+        // We are not interested in signals as no bindings are generated for them;
+        // they cause documentation warnings.
+        superFuncs.erase(std::remove_if(superFuncs.begin(), superFuncs.end(), isSignal),
+                         superFuncs.end());
         const auto virtuals = superClass->queryFunctions(FunctionQueryOption::VirtualInCppFunctions);
         superFuncs += virtuals;
 
@@ -1484,7 +1490,7 @@ void AbstractMetaClass::fixFunctions()
                 continue;
 
             // skip functions added in base classes
-            if (sf->isUserAdded() && sf->declaringClass() != this)
+            if (sf->isUserAdded() && sf->declaringClass() != klass)
                 continue;
 
             // Skip base class comparison operators declared as members (free
@@ -1496,42 +1502,24 @@ void AbstractMetaClass::fixFunctions()
             // virtual in case they override abstract functions.
             bool add = addSuperFunction(sf);
             for (const auto &cf : std::as_const(nonRemovedFuncs)) {
-                AbstractMetaFunctionPtr f(qSharedPointerConstCast<AbstractMetaFunction>(cf));
-                const AbstractMetaFunction::CompareResult cmp = cf->compareTo(sf.data());
+                AbstractMetaFunctionPtr f(std::const_pointer_cast<AbstractMetaFunction>(cf));
+                const AbstractMetaFunction::CompareResult cmp = cf->compareTo(sf.get());
 
                 if (cmp & AbstractMetaFunction::EqualModifiedName) {
                     add = false;
                     if (cmp & AbstractMetaFunction::EqualArguments) {
                         // Set "override" in case it was not spelled out (since it
                         // is then not detected by clang parsing).
-                        const auto attributes = cf->attributes();
-                        if (cf->isVirtual()
-                            && !attributes.testFlag(AbstractMetaFunction::OverriddenCppMethod)
-                            && !attributes.testFlag(AbstractMetaFunction::FinalCppMethod)) {
-                            *f += AbstractMetaFunction::OverriddenCppMethod;
-                        }
-                        // Same function, propegate virtual...
-                        if (!(cmp & AbstractMetaFunction::EqualAttributes)) {
-                            if (!f->isEmptyFunction()) {
-                                if (!sf->isFinalInTargetLang() && f->isFinalInTargetLang()) {
-                                    *f -= AbstractMetaFunction::FinalInTargetLang;
-                                }
-#if 0
-                                if (!f->isFinalInTargetLang() && f->isPrivate()) {
-                                    f->setFunctionType(AbstractMetaFunction::EmptyFunction);
-                                    f->setVisibility(AbstractMetaAttributes::Protected);
-                                    *f += AbstractMetaAttributes::FinalInTargetLang;
-                                    qCWarning(lcShiboken).noquote().nospace()
-                                        << QStringLiteral("private virtual function '%1' in '%2'")
-                                                          .arg(f->signature(), f->implementingClass()->name());
-                                }
-#endif
-                            }
+                        const auto attributes = cf->cppAttributes();
+                        if (attributes.testFlag(FunctionAttribute::Virtual)
+                            && !attributes.testFlag(FunctionAttribute::Override)
+                            && !attributes.testFlag(FunctionAttribute::Final)) {
+                            f->setCppAttribute(FunctionAttribute::Override);
                         }
 
                         if (f->access() != sf->access()) {
                             qCWarning(lcShiboken, "%s",
-                                      qPrintable(msgFunctionVisibilityModified(this, f.data())));
+                                      qPrintable(msgFunctionVisibilityModified(klass, f.get())));
 #if 0
                             // If new visibility is private, we can't
                             // do anything. If it isn't, then we
@@ -1543,43 +1531,12 @@ void AbstractMetaClass::fixFunctions()
                             // Private overrides of abstract functions have to go into the class or
                             // the subclasses will not compile as non-abstract classes.
                             // But they don't need to be implemented, since they can never be called.
-                            if (f->isPrivate()) {
+                            if (f->isPrivate())
                                 f->setFunctionType(AbstractMetaFunction::EmptyFunction);
-                                *f += AbstractMetaFunction::FinalInTargetLang;
-                            }
                         }
 
                         // Set the class which first declares this function, afawk
                         f->setDeclaringClass(sf->declaringClass());
-
-                        if (sf->isFinalInTargetLang() && !sf->isPrivate() && !f->isPrivate() && !sf->isStatic() && !f->isStatic()) {
-                            // Shadowed funcion, need to make base class
-                            // function non-virtual
-                            if (f->implementingClass() != sf->implementingClass() && f->implementingClass()->inheritsFrom(sf->implementingClass())) {
-
-                                // Check whether the superclass method has been redefined to non-final
-
-                                bool hasNonFinalModifier = false;
-                                bool isBaseImplPrivate = false;
-                                const FunctionModificationList &mods = sf->modifications(sf->implementingClass());
-                                for (const FunctionModification &mod : mods) {
-                                    if (mod.isNonFinal()) {
-                                        hasNonFinalModifier = true;
-                                        break;
-                                    }
-                                    if (mod.isPrivate()) {
-                                        isBaseImplPrivate = true;
-                                        break;
-                                    }
-                                }
-
-                                if (!hasNonFinalModifier && !isBaseImplPrivate) {
-                                    qCWarning(lcShiboken, "%s",
-                                              qPrintable(msgShadowingFunction(sf.data(), f.data())));
-                                }
-                            }
-                        }
-
                     }
 
                     if (cmp & AbstractMetaFunction::EqualDefaultValueOverload) {
@@ -1618,8 +1575,8 @@ void AbstractMetaClass::fixFunctions()
     bool hasPublicConstructors = false;
     // Apply modifications after the declaring class has been set
     for (const auto &func : std::as_const(funcs)) {
-        auto ncFunc = qSharedPointerConstCast<AbstractMetaFunction>(func);
-        for (const auto &mod : func->modifications(this)) {
+        auto ncFunc = std::const_pointer_cast<AbstractMetaFunction>(func);
+        for (const auto &mod : func->modifications(klass)) {
             if (mod.isRenameModifier())
                 ncFunc->setName(mod.renamedToName());
         }
@@ -1627,8 +1584,8 @@ void AbstractMetaClass::fixFunctions()
 
         // Make sure class is abstract if one of the functions is
         if (func->isAbstract()) {
-            (*this) += AbstractMetaClass::Abstract;
-            (*this) -= AbstractMetaClass::FinalInTargetLang;
+            (*klass) += AbstractMetaClass::Abstract;
+            (*klass) -= AbstractMetaClass::FinalInTargetLang;
         }
 
         if (func->isConstructor()) {
@@ -1641,15 +1598,15 @@ void AbstractMetaClass::fixFunctions()
 
 
         // Make sure that we include files for all classes that are in use
-        addExtraIncludesForFunction(this, func);
+        addExtraIncludesForFunction(klass, func);
     }
 
     if (hasPrivateConstructors && !hasPublicConstructors) {
-        (*this) += AbstractMetaClass::Abstract;
-        (*this) -= AbstractMetaClass::FinalInTargetLang;
+        (*klass) += AbstractMetaClass::Abstract;
+        (*klass) -= AbstractMetaClass::FinalInTargetLang;
     }
 
-    setFunctions(funcs);
+    d->setFunctions(funcs, klass);
 }
 
 bool AbstractMetaClass::needsInheritanceSetup() const
@@ -1658,6 +1615,7 @@ bool AbstractMetaClass::needsInheritanceSetup() const
         switch (d->m_typeEntry->type()) {
         case TypeEntry::NamespaceType:
         case TypeEntry::SmartPointerType:
+        case TypeEntry::ContainerType:
             return false;
         default:
             break;
@@ -1689,11 +1647,11 @@ std::optional<AbstractMetaEnumValue>
     if (lst.size() > 1) {
         const auto &prefixName = lst.at(0);
         const auto &enumName = lst.at(1);
-        if (auto *cl = findClass(classes, prefixName))
+        if (auto cl = findClass(classes, prefixName))
             return cl->findEnumValue(enumName.toString());
     }
 
-    for (AbstractMetaClass *metaClass : classes) {
+    for (const auto &metaClass : classes) {
         auto enumValue = metaClass->findEnumValue(name);
         if (enumValue.has_value())
             return enumValue;
@@ -1707,12 +1665,12 @@ std::optional<AbstractMetaEnumValue>
 /// Target language base name or complete Target language package.class name.
 
 template <class It>
-static It findClassHelper(It begin, It end, QStringView name)
+static It findClassHelper(It begin, It end, QAnyStringView name)
 {
     if (name.isEmpty() || begin == end)
         return end;
 
-    if (name.contains(u'.')) { // Search target lang name
+    if (asv_contains(name,'.')) { // Search target lang name
         for (auto it = begin; it != end; ++it) {
             if ((*it)->fullName() == name)
                 return it;
@@ -1725,7 +1683,7 @@ static It findClassHelper(It begin, It end, QStringView name)
             return it;
     }
 
-    if (name.contains(u"::")) // Qualified, cannot possibly match name
+    if (asv_contains(name, "::")) // Qualified, cannot possibly match name
         return end;
 
     for (auto it = begin; it != end; ++it) {
@@ -1736,31 +1694,31 @@ static It findClassHelper(It begin, It end, QStringView name)
     return end;
 }
 
-AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &classes,
-                                                QStringView name)
+AbstractMetaClassPtr AbstractMetaClass::findClass(const AbstractMetaClassList &classes,
+                                                  QAnyStringView name)
 {
     auto it =findClassHelper(classes.cbegin(), classes.cend(), name);
     return it != classes.cend() ? *it : nullptr;
 }
 
-const AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassCList &classes,
-                                                      QStringView name)
+AbstractMetaClassCPtr AbstractMetaClass::findClass(const AbstractMetaClassCList &classes,
+                                                   QAnyStringView name)
 {
     auto it = findClassHelper(classes.cbegin(), classes.cend(), name);
     return it != classes.cend() ? *it : nullptr;
 }
 
-AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &classes,
-                                                const TypeEntryCPtr &typeEntry)
+AbstractMetaClassPtr AbstractMetaClass::findClass(const AbstractMetaClassList &classes,
+                                                  const TypeEntryCPtr &typeEntry)
 {
-    for (AbstractMetaClass *c : classes) {
+    for (AbstractMetaClassPtr c : classes) {
         if (c->typeEntry() == typeEntry)
             return c;
     }
     return nullptr;
 }
 
-const AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassCList &classes,
+AbstractMetaClassCPtr AbstractMetaClass::findClass(const AbstractMetaClassCList &classes,
                                                       const TypeEntryCPtr &typeEntry)
 {
     for (auto c : classes) {
@@ -1771,40 +1729,41 @@ const AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassCLi
 }
 
 /// Returns true if this class is a subclass of the given class
-bool AbstractMetaClass::inheritsFrom(const AbstractMetaClass *cls) const
+bool inheritsFrom(const AbstractMetaClassCPtr &c, const AbstractMetaClassCPtr &cls)
 {
     Q_ASSERT(cls != nullptr);
 
-    if (this == cls || d->m_templateBaseClass == cls)
+    if (c == cls || c->templateBaseClass() == cls)
         return true;
 
-    return recurseClassHierarchy(this, [cls](const AbstractMetaClass *c) {
-        return cls == c;
-    }) != nullptr;
+    return bool(recurseClassHierarchy(c, [cls](const AbstractMetaClassCPtr &c) {
+        return cls.get() == c.get();
+    }));
 }
 
-bool AbstractMetaClass::inheritsFrom(const QString &name) const
+bool inheritsFrom(const AbstractMetaClassCPtr &c, QAnyStringView name)
 {
-    if (this->qualifiedCppName() == name)
+    if (c->qualifiedCppName() == name)
         return true;
 
-    if (d->m_templateBaseClass != nullptr
-        && d->m_templateBaseClass->qualifiedCppName() == name) {
+    if (c->templateBaseClass() != nullptr
+        && c->templateBaseClass()->qualifiedCppName() == name) {
         return true;
     }
 
-    return recurseClassHierarchy(this, [&name](const AbstractMetaClass *c) {
+    return bool(recurseClassHierarchy(c, [&name](const AbstractMetaClassCPtr &c) {
         return c->qualifiedCppName() == name;
-    }) != nullptr;
+    }));
 }
 
-const AbstractMetaClass *AbstractMetaClass::findBaseClass(const QString &qualifiedName) const
+AbstractMetaClassCPtr findBaseClass(const AbstractMetaClassCPtr &c,
+                                    const QString &qualifiedName)
 {
-    if (d->m_templateBaseClass != nullptr
-        && d->m_templateBaseClass->qualifiedCppName() == qualifiedName) {
-        return d->m_templateBaseClass;
-    }
-    return recurseClassHierarchy(this, [&qualifiedName](const AbstractMetaClass *c) {
+    auto tp = c->templateBaseClass();
+    if (tp && tp->qualifiedCppName() == qualifiedName)
+        return tp;
+
+    return recurseClassHierarchy(c, [&qualifiedName](const AbstractMetaClassCPtr &c) {
         return c->qualifiedCppName() == qualifiedName;
     });
 }
@@ -1834,7 +1793,7 @@ void AbstractMetaClass::setValueTypeWithCopyConstructorOnly(bool v)
     d->m_valueTypeWithCopyConstructorOnly = v;
 }
 
-bool AbstractMetaClass::determineValueTypeWithCopyConstructorOnly(const AbstractMetaClass *c,
+bool AbstractMetaClass::determineValueTypeWithCopyConstructorOnly(const AbstractMetaClassCPtr &c,
                                                                   bool avoidProtectedHack)
 {
 
@@ -1900,7 +1859,7 @@ void AbstractMetaClass::format(QDebug &debug) const
 
     if (!d->m_baseClasses.isEmpty()) {
         debug << ", inherits ";
-        for (auto b : d->m_baseClasses)
+        for (const auto &b : d->m_baseClasses)
             debug << " \"" << b->name() << '"';
     }
 
@@ -1965,6 +1924,18 @@ void AbstractMetaClass::setSourceLocation(const SourceLocation &sourceLocation)
     d->m_sourceLocation = sourceLocation;
 }
 
+AbstractMetaClassCList allBaseClasses(const AbstractMetaClassCPtr metaClass)
+{
+    AbstractMetaClassCList result;
+    recurseClassHierarchy(metaClass, [&result] (const AbstractMetaClassCPtr &c) {
+        if (!result.contains(c))
+            result.append(c);
+        return false;
+    });
+    result.removeFirst(); // remove self
+    return result;
+}
+
 QDebug operator<<(QDebug debug, const UsingMember &d)
 {
     QDebugStateSaver saver(debug);
@@ -1975,20 +1946,38 @@ QDebug operator<<(QDebug debug, const UsingMember &d)
     return debug;
 }
 
-QDebug operator<<(QDebug d, const AbstractMetaClass *ac)
+void formatMetaClass(QDebug &ddebug, const AbstractMetaClass *ac)
 {
-    QDebugStateSaver saver(d);
-    d.noquote();
-    d.nospace();
-    d << "AbstractMetaClass(";
-    if (ac) {
-        ac->format(d);
-        if (d.verbosity() > 2)
-            ac->formatMembers(d);
+    QDebugStateSaver saver(ddebug);
+    ddebug.noquote();
+    ddebug.nospace();
+    ddebug << "AbstractMetaClass(";
+    if (ac != nullptr) {
+        ac->format(ddebug);
+        if (ddebug.verbosity() > 2)
+            ac->formatMembers(ddebug);
     } else {
-        d << '0';
+        ddebug << '0';
     }
-    d << ')';
+    ddebug << ')';
+}
+
+QDebug operator<<(QDebug d, const AbstractMetaClassCPtr &ac)
+{
+    formatMetaClass(d, ac.get());
+    return d;
+}
+
+QDebug operator<<(QDebug d, const AbstractMetaClassPtr &ac)
+{
+    formatMetaClass(d, ac.get());
     return d;
 }
+
+QDebug operator<<(QDebug d, const AbstractMetaClass *ac)
+{
+    formatMetaClass(d, ac);
+    return d;
+}
+
 #endif // !QT_NO_DEBUG_STREAM
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.h b/sources/shiboken6/ApiExtractor/abstractmetalang.h
index 526df69af..3dc876690 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.h
@@ -66,11 +66,13 @@ public:
     ~AbstractMetaClass();
 
     const AbstractMetaFunctionCList &functions() const;
+    const AbstractMetaFunctionCList &userAddedPythonOverrides() const;
     void setFunctions(const AbstractMetaFunctionCList &functions);
-    void addFunction(const AbstractMetaFunctionCPtr &function);
+    static void addFunction(const AbstractMetaClassPtr &klass,
+                            const AbstractMetaFunctionCPtr &function);
     bool hasFunction(const QString &str) const;
-    AbstractMetaFunctionCPtr findFunction(QStringView functionName) const;
-    AbstractMetaFunctionCList findFunctions(QStringView functionName) const;
+    AbstractMetaFunctionCPtr findFunction(QAnyStringView functionName) const;
+    AbstractMetaFunctionCList findFunctions(QAnyStringView functionName) const;
     AbstractMetaFunctionCPtr findOperatorBool() const;
     // Find a Qt-style isNull() method suitable for nb_bool
     AbstractMetaFunctionCPtr findQtIsNullMethod() const;
@@ -81,8 +83,8 @@ public:
     bool hasCopyConstructor() const;
     bool hasPrivateCopyConstructor() const;
 
-    void addDefaultConstructor();
-    void addDefaultCopyConstructor();
+    static void addDefaultConstructor(const AbstractMetaClassPtr &klass);
+    static void addDefaultCopyConstructor(const AbstractMetaClassPtr &klass);
 
     bool hasNonPrivateConstructor() const;
     void setHasNonPrivateConstructor(bool value);
@@ -113,11 +115,7 @@ public:
     bool isImplicitlyCopyConstructible() const;
     bool canAddDefaultCopyConstructor() const;
 
-    /// Return type entry of the base class that declares the parent management
-    TypeEntryCPtr parentManagementEntry() const;
-    bool hasParentManagement() const { return !parentManagementEntry().isNull(); }
-
-    void addSynthesizedComparisonOperators();
+    static void addSynthesizedComparisonOperators(const AbstractMetaClassPtr &c);
 
     bool generateExceptionHandling() const;
 
@@ -125,7 +123,7 @@ public:
 
     const UsingMembers &usingMembers() const;
     void addUsingMember(const UsingMember &um);
-    bool isUsingMember(const AbstractMetaClass *c, const QString &memberName,
+    bool isUsingMember(const AbstractMetaClassCPtr &c, const QString &memberName,
                        Access minimumAccess) const;
     bool hasUsingMemberFor(const QString &memberName) const;
 
@@ -190,27 +188,27 @@ public:
 
     QString baseClassName() const;
 
-    const AbstractMetaClass *defaultSuperclass() const; // Attribute "default-superclass"
-    void setDefaultSuperclass(AbstractMetaClass *s);
+    AbstractMetaClassCPtr defaultSuperclass() const; // Attribute "default-superclass"
+    void setDefaultSuperclass(const AbstractMetaClassPtr &s);
 
-    const AbstractMetaClass *baseClass() const;
+    AbstractMetaClassCPtr baseClass() const;
     const AbstractMetaClassCList &baseClasses() const;
     // base classes including defaultSuperclass
     AbstractMetaClassCList typeSystemBaseClasses() const;
     // Recursive list of all base classes including defaultSuperclass
     AbstractMetaClassCList allTypeSystemAncestors() const;
 
-    void addBaseClass(const AbstractMetaClass *base_class);
-    void setBaseClass(const AbstractMetaClass *base_class);
+    void addBaseClass(const AbstractMetaClassCPtr &base_class);
+    void setBaseClass(const AbstractMetaClassCPtr &base_class);
 
     /**
      *   \return the namespace from another package which this namespace extends.
      */
-    const AbstractMetaClass *extendedNamespace() const;
-    void setExtendedNamespace(const AbstractMetaClass *e);
+    AbstractMetaClassCPtr extendedNamespace() const;
+    void setExtendedNamespace(const AbstractMetaClassCPtr &e);
 
     const AbstractMetaClassCList &innerClasses() const;
-    void addInnerClass(AbstractMetaClass *cl);
+    void addInnerClass(const AbstractMetaClassPtr &cl);
     void setInnerClasses(const AbstractMetaClassCList &innerClasses);
 
     QString package() const;
@@ -219,14 +217,11 @@ public:
     bool isInvisibleNamespace() const;
     bool isInlineNamespace() const;
 
-    bool isQObject() const;
     bool isQtNamespace() const;
 
     QString qualifiedCppName() const;
 
     bool hasSignals() const;
-    bool inheritsFrom(const AbstractMetaClass *other) const;
-    bool inheritsFrom(const QString &name) const;
 
     /**
     *   Says if the class that declares or inherits a virtual function.
@@ -292,8 +287,8 @@ public:
 
     void sortFunctions();
 
-    const AbstractMetaClass *templateBaseClass() const;
-    void setTemplateBaseClass(const AbstractMetaClass *cls);
+    AbstractMetaClassCPtr templateBaseClass() const;
+    void setTemplateBaseClass(const AbstractMetaClassCPtr &cls);
 
     bool hasTemplateBaseClassInstantiations() const;
     const AbstractMetaTypeList &templateBaseClassInstantiations() const;
@@ -317,18 +312,18 @@ public:
     bool isCopyable() const;
     bool isValueTypeWithCopyConstructorOnly() const;
     void setValueTypeWithCopyConstructorOnly(bool v);
-    static bool determineValueTypeWithCopyConstructorOnly(const AbstractMetaClass *c,
+    static bool determineValueTypeWithCopyConstructorOnly(const AbstractMetaClassCPtr &c,
                                                           bool avoidProtectedHack);
 
-    static AbstractMetaClass *findClass(const AbstractMetaClassList &classes,
-                                        QStringView name);
-    static const AbstractMetaClass *findClass(const AbstractMetaClassCList &classes,
-                                              QStringView name);
-    static AbstractMetaClass *findClass(const AbstractMetaClassList &classes,
+    static AbstractMetaClassPtr findClass(const AbstractMetaClassList &classes,
+                                          QAnyStringView name);
+    static AbstractMetaClassCPtr findClass(const AbstractMetaClassCList &classes,
+                                           QAnyStringView name);
+    static AbstractMetaClassPtr findClass(const AbstractMetaClassList &classes,
                                         const TypeEntryCPtr &typeEntry);
-    static const AbstractMetaClass *findClass(const AbstractMetaClassCList &classes,
+    static AbstractMetaClassCPtr findClass(const AbstractMetaClassCList &classes,
                                               const TypeEntryCPtr &typeEntry);
-    const AbstractMetaClass *findBaseClass(const QString &qualifiedName) const;
+    AbstractMetaClassCPtr findBaseClass(const QString &qualifiedName) const;
 
     static std::optional<AbstractMetaEnumValue> findEnumValue(const AbstractMetaClassList &classes,
                                                               const QString &string);
@@ -337,7 +332,7 @@ public:
     void setSourceLocation(const SourceLocation &sourceLocation);
 
     // For AbstractMetaBuilder
-    void fixFunctions();
+    static void fixFunctions(const AbstractMetaClassPtr &klass);
     bool needsInheritanceSetup() const;
     void setInheritanceDone(bool b);
     bool inheritanceDone() const;
@@ -349,17 +344,15 @@ private:
 #ifndef QT_NO_DEBUG_STREAM
     void format(QDebug &d) const;
     void formatMembers(QDebug &d) const;
+    friend QDebug operator<<(QDebug d, const AbstractMetaClassCPtr &ac);
+    friend QDebug operator<<(QDebug d, const AbstractMetaClassPtr &ac);
     friend QDebug operator<<(QDebug d, const AbstractMetaClass *ac);
+    friend void formatMetaClass(QDebug &, const AbstractMetaClass *);
 #endif
 
     QScopedPointer<AbstractMetaClassPrivate> d;
 };
 
-inline bool AbstractMetaClass::isFinalInTargetLang() const
-{
-    return attributes().testFlag(FinalInTargetLang);
-}
-
 inline bool AbstractMetaClass::isAbstract() const
 {
     return attributes().testFlag(Abstract);
@@ -368,7 +361,7 @@ inline bool AbstractMetaClass::isAbstract() const
 template <class Function>
 void AbstractMetaClass::invisibleNamespaceRecursion(Function f) const
 {
-    for (auto ic : innerClasses()) {
+    for (const auto &ic : innerClasses()) {
         if (ic->isInvisibleNamespace()) {
             f(ic);
             ic->invisibleNamespaceRecursion(f);
@@ -376,6 +369,23 @@ void AbstractMetaClass::invisibleNamespaceRecursion(Function f) const
     }
 }
 
+bool inheritsFrom(const AbstractMetaClassCPtr &c, const AbstractMetaClassCPtr &other);
+bool inheritsFrom(const AbstractMetaClassCPtr &c, QAnyStringView name);
+inline bool isQObject(const AbstractMetaClassCPtr &c)
+{
+    return inheritsFrom(c, "QObject");
+}
+
+AbstractMetaClassCPtr findBaseClass(const AbstractMetaClassCPtr &c,
+                                    const QString &qualifiedName);
+
+/// Return type entry of the base class that declares the parent management
+TypeEntryCPtr parentManagementEntry(const AbstractMetaClassCPtr &klass);
+inline bool hasParentManagement(const AbstractMetaClassCPtr &c)
+{ return bool(parentManagementEntry(c)); }
+
+AbstractMetaClassCList allBaseClasses(const AbstractMetaClassCPtr metaClass);
+
 Q_DECLARE_OPERATORS_FOR_FLAGS(AbstractMetaClass::CppWrapper);
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(AbstractMetaClass::Attributes);
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang_enums.h b/sources/shiboken6/ApiExtractor/abstractmetalang_enums.h
index 2bdfdb54d..9047c6bcd 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang_enums.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang_enums.h
@@ -11,18 +11,15 @@ enum class FunctionQueryOption {
     Constructors                 = 0x0000002, // Constructors except copy/move
     CopyConstructor              = 0x0000004, // Only copy constructors
     //Destructors                  = 0x0000002, // Only destructors. Not included in class.
-    FinalInTargetLangFunctions   = 0x0000008, // Only functions that are non-virtual in TargetLang
     ClassImplements              = 0x0000020, // Only functions implemented by the current class
     StaticFunctions              = 0x0000080, // Only static functions
     Signals                      = 0x0000100, // Only signals
     NormalFunctions              = 0x0000200, // Only functions that aren't signals
     Visible                      = 0x0000400, // Only public and protected functions
-    WasPublic                    = 0x0001000, // Only functions that were originally public
     NonStaticFunctions           = 0x0004000, // No static functions
     Empty                        = 0x0008000, // Empty overrides of abstract functions
     Invisible                    = 0x0010000, // Only private functions
     VirtualInCppFunctions        = 0x0020000, // Only functions that are virtual in C++
-    VirtualInTargetLangFunctions = 0x0080000, // Only functions which are virtual in TargetLang
     NotRemoved                   = 0x0400000, // Only functions that have not been removed
     OperatorOverloads            = 0x2000000, // Only functions that are operator overloads
     GenerateExceptionHandling    = 0x4000000,
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang_helpers.h b/sources/shiboken6/ApiExtractor/abstractmetalang_helpers.h
index c1deea2c2..2a053ceaf 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang_helpers.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang_helpers.h
@@ -4,21 +4,24 @@
 #ifndef ABSTRACTMETALANG_HELPERS_H
 #define ABSTRACTMETALANG_HELPERS_H
 
+#include "abstractmetalang_typedefs.h"
+
 template <class MetaClass>
-MetaClass *findByName(QList<MetaClass *> haystack, QStringView needle)
+std::shared_ptr<MetaClass> findByName(const QList<std::shared_ptr<MetaClass> > &haystack,
+                                      QStringView needle)
 {
-    for (MetaClass *c : haystack) {
+    for (const auto &c : haystack) {
         if (c->name() == needle)
             return c;
     }
-    return nullptr;
+    return {};
 }
 
 // Helper for recursing the base classes of an AbstractMetaClass.
 // Returns the class for which the predicate is true.
 template <class Predicate>
-const AbstractMetaClass *recurseClassHierarchy(const AbstractMetaClass *klass,
-                                               Predicate pred)
+AbstractMetaClassCPtr recurseClassHierarchy(const AbstractMetaClassCPtr &klass,
+                                            Predicate pred)
 {
     if (pred(klass))
         return klass;
@@ -26,7 +29,7 @@ const AbstractMetaClass *recurseClassHierarchy(const AbstractMetaClass *klass,
         if (auto r = recurseClassHierarchy(base, pred))
             return r;
     }
-    return nullptr;
+    return {};
 }
 
 #endif // ABSTRACTMETALANG_HELPERS_H
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
index 3b444197c..802f549cf 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
@@ -4,9 +4,10 @@
 #ifndef ABSTRACTMETALANG_TYPEDEFS_H
 #define ABSTRACTMETALANG_TYPEDEFS_H
 
-#include <QtCore/QSharedPointer>
 #include <QtCore/QList>
 
+#include <memory>
+
 class AbstractMetaClass;
 class AbstractMetaField;
 class AbstractMetaArgument;
@@ -16,12 +17,14 @@ class AbstractMetaFunction;
 class AbstractMetaType;
 struct UsingMember;
 
-using AbstractMetaFunctionPtr = QSharedPointer<AbstractMetaFunction>;
-using AbstractMetaFunctionCPtr = QSharedPointer<const AbstractMetaFunction>;
+using AbstractMetaFunctionPtr = std::shared_ptr<AbstractMetaFunction>;
+using AbstractMetaFunctionCPtr = std::shared_ptr<const AbstractMetaFunction>;
+using AbstractMetaClassPtr = std::shared_ptr<AbstractMetaClass>;
+using AbstractMetaClassCPtr = std::shared_ptr<const AbstractMetaClass>;
 
 using AbstractMetaArgumentList = QList<AbstractMetaArgument>;
-using AbstractMetaClassList = QList<AbstractMetaClass *>;
-using AbstractMetaClassCList = QList<const AbstractMetaClass *>;
+using AbstractMetaClassList = QList<AbstractMetaClassPtr>;
+using AbstractMetaClassCList = QList<AbstractMetaClassCPtr>;
 using AbstractMetaEnumList = QList<AbstractMetaEnum>;
 using AbstractMetaEnumValueList = QList<AbstractMetaEnumValue>;
 using AbstractMetaFieldList = QList<AbstractMetaField>;
diff --git a/sources/shiboken6/ApiExtractor/abstractmetatype.cpp b/sources/shiboken6/ApiExtractor/abstractmetatype.cpp
index 19e030330..3ec07509d 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetatype.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetatype.cpp
@@ -7,6 +7,8 @@
 #include "messages.h"
 #include "typedatabase.h"
 #include "containertypeentry.h"
+#include "enumtypeentry.h"
+#include "flagstypeentry.h"
 
 #include "qtcompat.h"
 #include "typeinfo.h"
@@ -17,12 +19,13 @@
 
 #include <QtCore/QHash>
 #include <QtCore/QSharedData>
-#include <QtCore/QSharedPointer>
 #include <QtCore/QStack>
 
+#include <memory>
+
 using namespace Qt::StringLiterals;
 
-using AbstractMetaTypeCPtr = QSharedPointer<const AbstractMetaType>;
+using AbstractMetaTypeCPtr = std::shared_ptr<const AbstractMetaType>;
 
 const QSet<QString> &AbstractMetaType::cppFloatTypes()
 {
@@ -116,6 +119,7 @@ public:
     QString formatPythonSignature() const;
     bool isEquivalent(const AbstractMetaTypeData &rhs) const;
     bool equals(const AbstractMetaTypeData &rhs) const;
+    QStringList instantiationCppSignatures() const;
 
     template <class Predicate>
     bool generateOpaqueContainer(Predicate p) const;
@@ -151,6 +155,14 @@ AbstractMetaTypeData::AbstractMetaTypeData(const TypeEntryCPtr &t) :
 {
 }
 
+QStringList AbstractMetaTypeData::instantiationCppSignatures() const
+{
+    QStringList result;
+    for (const auto &i : m_instantiations)
+        result.append(i.cppSignature());
+    return result;
+}
+
 AbstractMetaType::AbstractMetaType(const TypeEntryCPtr &t) :
     d(new AbstractMetaTypeData(t))
 {
@@ -166,9 +178,9 @@ AbstractMetaType &AbstractMetaType::operator=(const AbstractMetaType &) = defaul
 
 AbstractMetaType::AbstractMetaType(const AbstractMetaType &rhs) = default;
 
-AbstractMetaType::AbstractMetaType(AbstractMetaType &&) = default;
+AbstractMetaType::AbstractMetaType(AbstractMetaType &&) noexcept = default;
 
-AbstractMetaType &AbstractMetaType::operator=(AbstractMetaType &&) = default;
+AbstractMetaType &AbstractMetaType::operator=(AbstractMetaType &&) noexcept = default;
 
 AbstractMetaType::~AbstractMetaType() = default;
 
@@ -219,6 +231,11 @@ const AbstractMetaTypeList &AbstractMetaType::instantiations() const
     return d->m_instantiations;
 }
 
+QStringList AbstractMetaType::instantiationCppSignatures() const
+{
+    return d->instantiationCppSignatures();
+}
+
 // For applying the <array> function argument modification: change into a type
 // where "int *" becomes "int[]".
 bool AbstractMetaType::applyArrayModification(QString *errorMessage)
@@ -228,7 +245,7 @@ bool AbstractMetaType::applyArrayModification(QString *errorMessage)
         *errorMessage = u"<array> modification already applied."_s;
         return false;
     }
-    if (!d->m_arrayElementType.isNull())  {
+    if (d->m_arrayElementType)  {
         QTextStream(errorMessage) << "The type \"" << cppSignature()
             << "\" is an array of " << d->m_arrayElementType->name() << '.';
         return false;
@@ -276,13 +293,13 @@ QString AbstractMetaType::originalTypeDescription() const
 
 void AbstractMetaType::setOriginalTemplateType(const AbstractMetaType &type)
 {
-    if (d->m_originalTemplateType.isNull() || *d->m_originalTemplateType != type)
+    if (!d->m_originalTemplateType || *d->m_originalTemplateType != type)
         d->m_originalTemplateType.reset(new AbstractMetaType(type));
 }
 
 const AbstractMetaType *AbstractMetaType::originalTemplateType() const
 {
-    return d->m_originalTemplateType.data();
+    return d->m_originalTemplateType.get();
 }
 
 AbstractMetaType AbstractMetaType::getSmartPointerInnerType() const
@@ -311,7 +328,7 @@ AbstractMetaTypeList AbstractMetaType::nestedArrayTypes() const
         }
         break;
     case NativePointerAsArrayPattern:
-        result.append(*d->m_arrayElementType.data());
+        result.append(*d->m_arrayElementType.get());
         break;
     default:
         break;
@@ -339,6 +356,12 @@ bool AbstractMetaType::passByValue() const
     return d->passByValue();
 }
 
+bool AbstractMetaType::useStdMove() const
+{
+    return (isUniquePointer() && d->passByValue())
+        || d->m_referenceType == RValueReference;
+}
+
 ReferenceType AbstractMetaType::referenceType() const
 {
     return d->m_referenceType;
@@ -417,17 +440,28 @@ int AbstractMetaType::arrayElementCount() const
 
 const AbstractMetaType *AbstractMetaType::arrayElementType() const
 {
-    return d->m_arrayElementType.data();
+    return d->m_arrayElementType.get();
 }
 
 void AbstractMetaType::setArrayElementType(const AbstractMetaType &t)
 {
-    if (d->m_arrayElementType.isNull() || *d->m_arrayElementType != t) {
+    if (!d->m_arrayElementType || *d->m_arrayElementType != t) {
         d->m_arrayElementType.reset(new AbstractMetaType(t));
         d->m_signaturesDirty = true;
     }
 }
 
+AbstractMetaType AbstractMetaType::plainType() const
+{
+    AbstractMetaType result = *this;
+    result.clearIndirections();
+    result.setReferenceType(NoReference);
+    result.setConstant(false);
+    result.setVolatile(false);
+    result.decideUsagePattern();
+    return result;
+}
+
 QString AbstractMetaType::cppSignature() const
 {
     const AbstractMetaTypeData *cd = d.constData();
@@ -509,6 +543,7 @@ void AbstractMetaType::decideUsagePattern()
         pattern = ObjectPattern;
     }
     setTypeUsagePattern(pattern);
+    Q_ASSERT(pattern != ContainerPattern || !d->m_instantiations.isEmpty());
 }
 
 bool AbstractMetaTypeData::hasTemplateChildren() const
@@ -542,6 +577,29 @@ static inline QString formatArraySize(int e)
     return result;
 }
 
+// Return the number of template parameters; remove the default
+// non template type parameter of std::span from the signature.
+static qsizetype stripDefaultTemplateArgs(const TypeEntryCPtr &te,
+                                          const AbstractMetaTypeList &instantiations)
+{
+    static const char16_t dynamicExtent64[] = u"18446744073709551615"; // size_t(-1)
+    static const char16_t dynamicExtent32[] = u"4294967295";
+
+    qsizetype result = instantiations.size();
+    if (result == 0 || !te->isContainer())
+        return result;
+    auto cte = std::static_pointer_cast<const ContainerTypeEntry>(te);
+    if (cte->containerKind() != ContainerTypeEntry::SpanContainer)
+        return result;
+    const auto lastTe = instantiations.constLast().typeEntry();
+    if (lastTe->type() == TypeEntry::ConstantValueType) {
+        const QString &name = lastTe->name();
+        if (name == dynamicExtent64 || name == dynamicExtent32)
+           --result;
+    }
+    return result;
+}
+
 QString AbstractMetaTypeData::formatSignature(bool minimal) const
 {
     QString result;
@@ -564,12 +622,13 @@ QString AbstractMetaTypeData::formatSignature(bool minimal) const
         result += u'<';
         if (minimal)
             result += u' ';
-        for (qsizetype i = 0, size = m_instantiations.size(); i < size; ++i) {
+        const auto size = stripDefaultTemplateArgs(m_typeEntry, m_instantiations);
+        for (qsizetype i = 0; i < size; ++i) {
             if (i > 0)
                 result += u',';
             result += m_instantiations.at(i).minimalSignature();
         }
-        result += u" >"_s;
+        result += u'>';
     }
 
     if (!minimal && (!m_indirections.isEmpty() || m_referenceType != NoReference))
@@ -642,10 +701,12 @@ QString AbstractMetaTypeData::formatPythonSignature() const
     if (m_typeEntry->isPrimitive())
         for (Indirection i : m_indirections)
             result += TypeInfo::indirectionKeyword(i);
-    // If it is a flags type, we replace it with the full name:
-    // "PySide6.QtCore.Qt.ItemFlags" instead of "PySide6.QtCore.QFlags<Qt.ItemFlag>"
-    if (m_typeEntry->isFlags())
-        result = m_typeEntry->qualifiedTargetLangName();
+    // If it is a flags type, we replace it with the full name of the enum:
+    // "PySide6.QtCore.Qt.ItemFlag" instead of "PySide6.QtCore.QFlags<Qt.ItemFlag>"
+    if (m_typeEntry->isFlags()) {
+        const auto fte = std::static_pointer_cast<const FlagsTypeEntry>(m_typeEntry);
+        result = fte->originator()->qualifiedTargetLangName();
+    }
     result.replace(u"::"_s, u"."_s);
     return result;
 }
@@ -688,9 +749,9 @@ void AbstractMetaType::setVolatile(bool v)
 
 static bool equalsCPtr(const AbstractMetaTypeCPtr &t1, const AbstractMetaTypeCPtr &t2)
 {
-    if (t1.isNull() != t2.isNull())
+    if (bool(t1) != bool(t2))
         return false;
-    return t1.isNull() || *t1 == *t2;
+    return !t1 || *t1 == *t2;
 }
 
 bool AbstractMetaTypeData::isEquivalent(const AbstractMetaTypeData &rhs) const
@@ -718,9 +779,9 @@ bool AbstractMetaTypeData::equals(const AbstractMetaTypeData &rhs) const
         && m_referenceType == rhs.m_referenceType && isEquivalent(rhs);
 }
 
-bool AbstractMetaType::equals(const AbstractMetaType &rhs) const
+bool comparesEqual(const AbstractMetaType &lhs, const AbstractMetaType &rhs) noexcept
 {
-    return d->equals(*rhs.d);
+    return lhs.d->equals(*rhs.d);
 }
 
 bool AbstractMetaType::isEquivalent(const AbstractMetaType &rhs) const
@@ -730,12 +791,12 @@ bool AbstractMetaType::isEquivalent(const AbstractMetaType &rhs) const
 
 const AbstractMetaType *AbstractMetaType::viewOn() const
 {
-    return d->m_viewOn.data();
+    return d->m_viewOn.get();
 }
 
 void AbstractMetaType::setViewOn(const AbstractMetaType &v)
 {
-    if (d->m_viewOn.isNull() || *d->m_viewOn != v)
+    if (!d->m_viewOn || *d->m_viewOn != v)
         d->m_viewOn.reset(new AbstractMetaType(v));
 }
 
@@ -744,7 +805,7 @@ AbstractMetaType AbstractMetaType::createVoid()
     static QScopedPointer<AbstractMetaType> metaType;
     if (metaType.isNull()) {
         static TypeEntryCPtr voidTypeEntry = TypeDatabase::instance()->findType(u"void"_s);
-        Q_ASSERT(!voidTypeEntry.isNull());
+        Q_ASSERT(voidTypeEntry);
         metaType.reset(new AbstractMetaType(voidTypeEntry));
         metaType->decideUsagePattern();
     }
@@ -871,7 +932,7 @@ bool AbstractMetaType::isValueTypeWithCopyConstructorOnly() const
 {
     bool result = false;
     if (d->m_typeEntry->isComplex()) {
-        const auto cte = qSharedPointerCast<const ComplexTypeEntry>(d->m_typeEntry);
+        const auto cte = std::static_pointer_cast<const ComplexTypeEntry>(d->m_typeEntry);
         result = cte->isValueTypeWithCopyConstructorOnly();
     }
     return result;
@@ -888,14 +949,18 @@ using AbstractMetaTypeCache = QHash<QString, AbstractMetaType>;
 Q_GLOBAL_STATIC(AbstractMetaTypeCache, metaTypeFromStringCache)
 
 std::optional<AbstractMetaType>
-AbstractMetaType::fromString(QString typeSignature, QString *errorMessage)
+AbstractMetaType::fromString(const QString &typeSignatureIn, QString *errorMessage)
 {
-    typeSignature = typeSignature.trimmed();
+    auto &cache = *metaTypeFromStringCache();
+    auto it = cache.find(typeSignatureIn);
+    if (it != cache.end())
+        return it.value();
+
+    QString typeSignature = typeSignatureIn.trimmed();
     if (typeSignature.startsWith(u"::"))
         typeSignature.remove(0, 2);
 
-    auto &cache = *metaTypeFromStringCache();
-    auto it = cache.find(typeSignature);
+    it = cache.find(typeSignature);
     if (it == cache.end()) {
         auto metaType =
             AbstractMetaBuilder::translateType(typeSignature, nullptr, {}, errorMessage);
@@ -904,6 +969,8 @@ AbstractMetaType::fromString(QString typeSignature, QString *errorMessage)
                 errorMessage->prepend(msgCannotBuildMetaType(typeSignature));
             return {};
         }
+        if (typeSignature != typeSignatureIn)
+            cache.insert(typeSignatureIn, metaType.value());
         it = cache.insert(typeSignature, metaType.value());
     }
     return it.value();
@@ -918,16 +985,12 @@ AbstractMetaType AbstractMetaType::fromTypeEntry(const TypeEntryCPtr &typeEntry)
     auto it = cache.find(typeName);
     if (it != cache.end())
         return it.value();
-    AbstractMetaType metaType(typeEntry);
-    metaType.clearIndirections();
-    metaType.setReferenceType(NoReference);
-    metaType.setConstant(false);
-    metaType.decideUsagePattern();
+    AbstractMetaType metaType = AbstractMetaType(typeEntry).plainType();
     cache.insert(typeName, metaType);
     return metaType;
 }
 
-AbstractMetaType AbstractMetaType::fromAbstractMetaClass(const AbstractMetaClass *metaClass)
+AbstractMetaType AbstractMetaType::fromAbstractMetaClass(const AbstractMetaClassCPtr &metaClass)
 {
     return fromTypeEntry(metaClass->typeEntry());
 }
@@ -940,37 +1003,34 @@ bool AbstractMetaTypeData::generateOpaqueContainer(Predicate pred) const
         return false;
     if (m_indirections.size() > 1)
         return false;
-    auto containerTypeEntry = qSharedPointerCast<const ContainerTypeEntry>(m_typeEntry);
+    auto containerTypeEntry = std::static_pointer_cast<const ContainerTypeEntry>(m_typeEntry);
     auto kind = containerTypeEntry->containerKind();
-    if (kind != ContainerTypeEntry::ListContainer)
-        return false;
-    const auto &instantation =  m_instantiations.constFirst();
-    if (instantation.referenceType() != NoReference)
+    if (kind != ContainerTypeEntry::ListContainer && kind != ContainerTypeEntry::SpanContainer)
         return false;
-    const QString signature = instantation.cppSignature();
 
-    bool result = false;
-    auto instTypEntry = instantation.typeEntry();
-    switch (instTypEntry->type()) {
+    const auto &firstInstantiation = m_instantiations.constFirst();
+    if (firstInstantiation.referenceType() != NoReference)
+        return false;
+    switch (firstInstantiation.typeEntry()->type()) {
     case TypeEntry::PrimitiveType:
     case TypeEntry::FlagsType:
     case TypeEntry::EnumType:
     case TypeEntry::BasicValueType:
     case TypeEntry::ObjectType:
     case TypeEntry::CustomType:
-        result = pred(containerTypeEntry, signature);
         break;
     default:
-        break;
+        return false;
     }
-    return result;
+
+    return pred(containerTypeEntry, instantiationCppSignatures());
 }
 
 // Simple predicate for checking whether an opaque container should be generated
 static bool opaqueContainerPredicate(const ContainerTypeEntryCPtr &t,
-                                     const QString &signature)
+                                     const QStringList &instantiations)
 {
-    return t->generateOpaqueContainer(signature);
+    return t->generateOpaqueContainer(instantiations);
 }
 
 bool AbstractMetaType::generateOpaqueContainer() const
@@ -983,8 +1043,9 @@ bool AbstractMetaType::generateOpaqueContainer() const
 // (cf AbstractMetaFunction::generateOpaqueContainerReturn())
 bool AbstractMetaType::generateOpaqueContainerForGetter(const QString &modifiedType) const
 {
-    auto predicate = [&modifiedType](const ContainerTypeEntryCPtr &t, const QString &signature) {
-        return t->opaqueContainerName(signature) == modifiedType;
+    auto predicate = [&modifiedType](const ContainerTypeEntryCPtr &t,
+                                     const QStringList &instantiations) {
+        return t->opaqueContainerName(instantiations) == modifiedType;
     };
     return d->generateOpaqueContainer(predicate);
 }
@@ -1008,7 +1069,7 @@ void AbstractMetaType::formatDebug(QDebug &debug) const
             for (auto i : indirections)
                 debug << ' ' << TypeInfo::indirectionKeyword(i);
         }
-        if (referenceType())
+        if (referenceType() != NoReference)
             debug << ", reftype=" << referenceType();
         if (isConstant())
             debug << ", [const]";
diff --git a/sources/shiboken6/ApiExtractor/abstractmetatype.h b/sources/shiboken6/ApiExtractor/abstractmetatype.h
index 237c33d20..8a1ecdf20 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetatype.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetatype.h
@@ -9,7 +9,9 @@
 #include "parser/codemodel_enums.h"
 #include "typedatabase_typedefs.h"
 
+#include <QtCore/QtCompare>
 #include <QtCore/qobjectdefs.h>
+#include <QtCore/QHashFunctions>
 #include <QtCore/QSharedDataPointer>
 #include <QtCore/QList>
 #include <QtCore/QSet>
@@ -50,8 +52,8 @@ public:
     explicit AbstractMetaType(const TypeEntryCPtr &t);
     AbstractMetaType(const AbstractMetaType &);
     AbstractMetaType &operator=(const AbstractMetaType &);
-    AbstractMetaType(AbstractMetaType &&);
-    AbstractMetaType &operator=(AbstractMetaType &&);
+    AbstractMetaType(AbstractMetaType &&) noexcept;
+    AbstractMetaType &operator=(AbstractMetaType &&) noexcept;
     ~AbstractMetaType();
 
     QString package() const;
@@ -67,6 +69,7 @@ public:
     const AbstractMetaTypeList &instantiations() const;
     void addInstantiation(const AbstractMetaType &inst);
     void setInstantiations(const AbstractMetaTypeList  &insts);
+    QStringList instantiationCppSignatures() const;
 
     QString minimalSignature() const { return formatSignature(true); }
 
@@ -118,6 +121,7 @@ public:
 
     bool passByConstRef() const;
     bool passByValue() const;
+    bool useStdMove() const;
 
     ReferenceType referenceType() const;
     void setReferenceType(ReferenceType ref);
@@ -141,6 +145,9 @@ public:
 
     AbstractMetaTypeList nestedArrayTypes() const;
 
+    /// Strip const/indirections/reference from the type
+    AbstractMetaType plainType() const;
+
     QString cppSignature() const;
 
     QString pythonSignature() const;
@@ -165,7 +172,6 @@ public:
 
     bool hasTemplateChildren() const;
 
-    bool equals(const AbstractMetaType &rhs) const;
     /// Is equivalent from the POV of argument passing (differ by const ref)
     bool isEquivalent(const AbstractMetaType &rhs) const;
 
@@ -182,11 +188,11 @@ public:
     /// \param typeSignature The string describing the type to be built.
     /// \return A new AbstractMetaType object or nullopt in case of failure.
     static std::optional<AbstractMetaType>
-        fromString(QString typeSignature, QString *errorMessage = nullptr);
+        fromString(const QString &typeSignatureIn, QString *errorMessage = nullptr);
     /// Creates an AbstractMetaType object from a TypeEntry.
     static AbstractMetaType fromTypeEntry(const TypeEntryCPtr &typeEntry);
     /// Creates an AbstractMetaType object from an AbstractMetaClass.
-    static AbstractMetaType fromAbstractMetaClass(const AbstractMetaClass *metaClass);
+    static AbstractMetaType fromAbstractMetaClass(const AbstractMetaClassCPtr &metaClass);
 
     static void dereference(QString *type); // "foo" -> "(*foo)"
     /// Apply the result of shouldDereferenceArgument()
@@ -248,6 +254,12 @@ public:
 #endif
 
 private:
+    friend size_t qHash(const AbstractMetaType &t, size_t seed = 0) noexcept
+    { return qHash(t.typeEntry().get(), seed); }
+    friend bool comparesEqual(const AbstractMetaType &lhs,
+                              const AbstractMetaType &rhs) noexcept;
+    Q_DECLARE_EQUALITY_COMPARABLE(AbstractMetaType)
+
     friend class AbstractMetaTypeData;
     QSharedDataPointer<AbstractMetaTypeData> d;
 
@@ -256,14 +268,6 @@ private:
     QString formatPythonSignature() const;
 };
 
-inline bool operator==(const AbstractMetaType &t1, const AbstractMetaType &t2)
-{ return t1.equals(t2); }
-inline bool operator!=(const AbstractMetaType &t1, const AbstractMetaType &t2)
-{ return !t1.equals(t2); }
-
-inline size_t qHash(const AbstractMetaType &t, size_t seed)
-{ return qHash(t.typeEntry(), seed); }
-
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug d, const AbstractMetaType &at);
 QDebug operator<<(QDebug d, const AbstractMetaType *at);
diff --git a/sources/shiboken6/ApiExtractor/addedfunction.cpp b/sources/shiboken6/ApiExtractor/addedfunction.cpp
index 6525c1ed7..9d95b734c 100644
--- a/sources/shiboken6/ApiExtractor/addedfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/addedfunction.cpp
@@ -9,18 +9,13 @@
 
 using namespace Qt::StringLiterals;
 
-static inline QString callOperator() { return QStringLiteral("operator()"); }
+constexpr auto callOperator = "operator()"_L1;
 
 // Helpers to split a parameter list of <add-function>, <declare-function>
 // (@ denoting names), like
 // "void foo(QList<X,Y> &@list@ = QList<X,Y>{1,2}, int @b@=5, ...)"
 namespace AddedFunctionParser {
 
-bool Argument::equals(const Argument &rhs) const
-{
-    return type == rhs.type && name == rhs.name && defaultValue == rhs.defaultValue;
-}
-
 QDebug operator<<(QDebug d, const Argument &a)
 {
     QDebugStateSaver saver(d);
@@ -87,7 +82,7 @@ Arguments splitParameters(QStringView paramString, QString *errorMessage)
     for (const auto &t : tokens) {
         Argument argument;
         // Check defaultValue, "int @b@=5"
-        const int equalPos = t.lastIndexOf(u'=');
+        const auto equalPos = t.lastIndexOf(u'=');
         if (equalPos != -1) {
             const int defaultValuePos = equalPos + 1;
             argument.defaultValue =
@@ -95,7 +90,7 @@ Arguments splitParameters(QStringView paramString, QString *errorMessage)
         }
         QString typeString = (equalPos != -1 ? t.left(equalPos) : t).trimmed().toString();
         // Check @name@
-        const int atPos = typeString.indexOf(u'@');
+        const auto atPos = typeString.indexOf(u'@');
         if (atPos != -1) {
             const int namePos = atPos + 1;
             const int nameEndPos = typeString.indexOf(u'@', namePos);
@@ -143,16 +138,16 @@ AddedFunction::AddedFunctionPtr
     QStringView signature = QStringView{signatureIn}.trimmed();
 
     // Skip past "operator()(...)"
-    const int parenSearchStartPos = signature.startsWith(callOperator())
-        ? callOperator().size() : 0;
-    const int openParenPos = signature.indexOf(u'(', parenSearchStartPos);
+    const auto parenSearchStartPos = signature.startsWith(callOperator)
+        ? callOperator.size() : 0;
+    const auto openParenPos = signature.indexOf(u'(', parenSearchStartPos);
     if (openParenPos < 0) {
         return AddedFunctionPtr(new AddedFunction(signature.toString(),
                                                   arguments, returnType));
     }
 
     const QString name = signature.left(openParenPos).trimmed().toString();
-    const int closingParenPos = signature.lastIndexOf(u')');
+    const auto closingParenPos = signature.lastIndexOf(u')');
     if (closingParenPos < 0) {
         *errorMessage = u"Missing closing parenthesis"_s;
         return {};
@@ -160,8 +155,8 @@ AddedFunction::AddedFunctionPtr
 
     // Check for "foo() const"
     bool isConst = false;
-    const int signatureLength = signature.length();
-    const int qualifierLength = signatureLength - closingParenPos - 1;
+    const auto signatureLength = signature.length();
+    const auto qualifierLength = signatureLength - closingParenPos - 1;
     if (qualifierLength >= 5
         && signature.right(qualifierLength).contains(u"const")) {
         isConst = true;
@@ -182,7 +177,7 @@ AddedFunction::AddedFunctionPtr
         arguments.append({type, p.name, p.defaultValue});
     }
 
-    AddedFunctionPtr result(new AddedFunction(name, arguments, returnType));
+    auto result = std::make_shared<AddedFunction>(name, arguments, returnType);
     result->setConstant(isConst);
     return result;
 }
diff --git a/sources/shiboken6/ApiExtractor/addedfunction.h b/sources/shiboken6/ApiExtractor/addedfunction.h
index 0f5dc89ef..b8d189b7a 100644
--- a/sources/shiboken6/ApiExtractor/addedfunction.h
+++ b/sources/shiboken6/ApiExtractor/addedfunction.h
@@ -8,9 +8,10 @@
 #include "parser/typeinfo.h"
 
 #include <QtCore/QList>
-#include <QtCore/QSharedPointer>
 #include <QtCore/QString>
 
+#include <memory>
+
 QT_FORWARD_DECLARE_CLASS(QDebug)
 
 /// \internal
@@ -19,7 +20,7 @@ QT_FORWARD_DECLARE_CLASS(QDebug)
 /// will be inserted into the right AbstractMetaClass.
 struct AddedFunction
 {
-    using AddedFunctionPtr = QSharedPointer<AddedFunction>;
+    using AddedFunctionPtr = std::shared_ptr<AddedFunction>;
 
     /// Function access types.
     enum Access {
@@ -78,6 +79,9 @@ struct AddedFunction
     bool isDeclaration() const { return m_isDeclaration; } // <declare-function>
     void setDeclaration(bool value) { m_isDeclaration = value; }
 
+    bool isPythonOverride() const { return m_isPythonOverride; }
+    void setPythonOverride(bool o) { m_isPythonOverride = o; }
+
     const FunctionModificationList &modifications() const { return m_modifications; }
     FunctionModificationList &modifications() { return m_modifications; }
 
@@ -85,17 +89,22 @@ struct AddedFunction
     DocModificationList &docModifications() { return m_docModifications; }
     void addDocModification(const DocModification &m) { m_docModifications.append(m); }
 
+    QString targetLangPackage() const { return m_targetLangPackage; }
+    void setTargetLangPackage(const QString &p) { m_targetLangPackage = p; }
+
 private:
     QString m_name;
     QList<Argument> m_arguments;
     TypeInfo m_returnType;
     FunctionModificationList m_modifications;
     DocModificationList m_docModifications;
+    QString m_targetLangPackage;
     Access m_access = Public;
     bool m_isConst = false;
     bool m_isClassMethod = false;
     bool m_isStatic = false;
     bool m_isDeclaration = false;
+    bool m_isPythonOverride = false;
 };
 
 QDebug operator<<(QDebug d, const AddedFunction::Argument &a);
diff --git a/sources/shiboken6/ApiExtractor/addedfunction_p.h b/sources/shiboken6/ApiExtractor/addedfunction_p.h
index 9915871ad..40b69a5df 100644
--- a/sources/shiboken6/ApiExtractor/addedfunction_p.h
+++ b/sources/shiboken6/ApiExtractor/addedfunction_p.h
@@ -4,6 +4,7 @@
 #ifndef ADDEDFUNCTION_P_H
 #define ADDEDFUNCTION_P_H
 
+#include <QtCore/QtCompare>
 #include <QtCore/QList>
 #include <QtCore/QString>
 #include <QtCore/QStringView>
@@ -19,18 +20,20 @@ namespace AddedFunctionParser {
 
 struct Argument
 {
-    bool equals(const Argument &rhs) const;
-
     QString type;
     QString name;
     QString defaultValue;
+
+    friend bool comparesEqual(const Argument &lhs, const Argument &rhs) noexcept
+    {
+        return lhs.type == rhs.type && lhs.name == rhs.name
+               && lhs.defaultValue == rhs.defaultValue;
+    }
+    Q_DECLARE_EQUALITY_COMPARABLE(Argument)
 };
 
 using Arguments = QList<Argument>;
 
-inline bool operator==(const Argument &a1, const Argument &a2) { return a1.equals(a2); }
-inline bool operator!=(const Argument &a1, const Argument &a2) { return !a1.equals(a2); }
-
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug d, const Argument &a);
 #endif
diff --git a/sources/shiboken6/ApiExtractor/anystringview_helpers.cpp b/sources/shiboken6/ApiExtractor/anystringview_helpers.cpp
new file mode 100644
index 000000000..35d2d535a
--- /dev/null
+++ b/sources/shiboken6/ApiExtractor/anystringview_helpers.cpp
@@ -0,0 +1,56 @@
+// 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 "anystringview_helpers.h"
+
+#include <QtCore/QString> // Must go before QAnyStringView for operator<<(QTextStream,QASV)!
+#include <QtCore/QAnyStringView>
+#include <QtCore/QDebug>
+#include <QtCore/QTextStream>
+
+#include <cstring>
+
+QTextStream &operator<<(QTextStream &str, QAnyStringView asv)
+{
+    asv.visit([&str](auto s) { str << s; });
+    return str;
+}
+
+static bool asv_containsImpl(QLatin1StringView v, char c)
+{
+    return v.contains(uint16_t(c));
+}
+
+static bool asv_containsImpl(QUtf8StringView v, char c)
+{
+    return std::strchr(v.data(), c) != nullptr;
+}
+
+static bool asv_containsImpl(QStringView v, char c)
+{
+    return v.contains(uint16_t(c));
+}
+
+bool asv_contains(QAnyStringView asv, char needle)
+{
+    return asv.visit([needle](auto s) { return asv_containsImpl(s, needle); });
+}
+
+static bool asv_containsImpl(QLatin1StringView v, const char *c)
+{
+    return v.contains(QLatin1StringView(c));
+}
+static bool asv_containsImpl(QUtf8StringView v, const char *c)
+{
+    return std::strstr(v.data(), c) != nullptr;
+}
+
+static bool asv_containsImpl(QStringView v, const char *c)
+{
+    return v.contains(QLatin1StringView(c));
+}
+
+bool asv_contains(QAnyStringView asv, const char *needle)
+{
+    return asv.visit([needle](auto s) { return asv_containsImpl(s, needle); });
+}
diff --git a/sources/shiboken6/ApiExtractor/anystringview_helpers.h b/sources/shiboken6/ApiExtractor/anystringview_helpers.h
new file mode 100644
index 000000000..e1e6ab7f0
--- /dev/null
+++ b/sources/shiboken6/ApiExtractor/anystringview_helpers.h
@@ -0,0 +1,18 @@
+// 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 ANYSTRINGVIEW_STREAM_H
+#define ANYSTRINGVIEW_STREAM_H
+
+#include <QtCore/QtClassHelperMacros>
+
+QT_FORWARD_DECLARE_CLASS(QAnyStringView)
+QT_FORWARD_DECLARE_CLASS(QTextStream)
+QT_FORWARD_DECLARE_CLASS(QDebug)
+
+QTextStream &operator<<(QTextStream &str, QAnyStringView asv);
+
+bool asv_contains(QAnyStringView asv, char needle);
+bool asv_contains(QAnyStringView asv, const char *needle);
+
+#endif // ANYSTRINGVIEW_STREAM_H
diff --git a/sources/shiboken6/ApiExtractor/apiextractor.cpp b/sources/shiboken6/ApiExtractor/apiextractor.cpp
index 2e22f21e3..786cd0783 100644
--- a/sources/shiboken6/ApiExtractor/apiextractor.cpp
+++ b/sources/shiboken6/ApiExtractor/apiextractor.cpp
@@ -3,7 +3,6 @@
 
 #include "apiextractor.h"
 #include "apiextractorresult.h"
-#include "apiextractorresultdata_p.h"
 #include "abstractmetaargument.h"
 #include "abstractmetabuilder.h"
 #include "abstractmetaenum.h"
@@ -14,6 +13,7 @@
 #include "exception.h"
 #include "messages.h"
 #include "modifications.h"
+#include "optionsparser.h"
 #include "reporthandler.h"
 #include "typedatabase.h"
 #include "customconversion.h"
@@ -43,7 +43,186 @@ struct InstantiationCollectContext
     QStringList instantiatedContainersNames;
 };
 
-struct ApiExtractorPrivate
+struct ApiExtractorOptions
+{
+    QString m_typeSystemFileName;
+    QFileInfoList m_cppFileNames;
+    HeaderPaths m_includePaths;
+    QStringList m_clangOptions;
+    QString m_logDirectory;
+    LanguageLevel m_languageLevel = LanguageLevel::Default;
+    bool m_skipDeprecated = false;
+};
+
+static inline QString languageLevelDescription()
+{
+    return u"C++ Language level (c++11..c++17, default="_s
+           + QLatin1StringView(clang::languageLevelOption(clang::emulatedCompilerLanguageLevel()))
+           + u')';
+}
+
+QList<OptionDescription> ApiExtractor::options()
+{
+    return {
+        {u"use-global-header"_s,
+         u"Use the global headers in generated code."_s},
+        {u"clang-option"_s,
+         u"Option to be passed to clang"_s},
+        {u"clang-options"_s,
+         u"A comma-separated list of options to be passed to clang"_s},
+        {u"skip-deprecated"_s,
+         u"Skip deprecated functions"_s},
+        {u"-F<path>"_s, {} },
+        {u"framework-include-paths="_s + OptionsParser::pathSyntax(),
+         u"Framework include paths used by the C++ parser"_s},
+        {u"-isystem<path>"_s, {} },
+        {u"system-include-paths="_s + OptionsParser::pathSyntax(),
+         u"System include paths used by the C++ parser"_s},
+        {u"language-level=, -std=<level>"_s,
+         languageLevelDescription()},
+    };
+}
+
+class ApiExtractorOptionsParser : public OptionsParser
+{
+public:
+    explicit ApiExtractorOptionsParser(ApiExtractorOptions *o) : m_options(o) {}
+
+    bool handleBoolOption(const QString &key, OptionSource source) override;
+    bool handleOption(const QString &key, const QString &value,
+                      OptionSource source) override;
+
+private:
+    void parseIncludePathOption(const QString &value, HeaderType headerType);
+    void parseIncludePathOption(const QStringList &values, HeaderType headerType);
+    void setLanguageLevel(const QString &value);
+
+    ApiExtractorOptions *m_options;
+};
+
+void ApiExtractorOptionsParser::parseIncludePathOption(const QString &value,
+                                                       HeaderType headerType)
+{
+    if (value.isEmpty())
+        throw Exception(u"Empty value passed to include path option"_s);
+    const auto path = QFile::encodeName(QDir::cleanPath(value));
+    m_options->m_includePaths.append(HeaderPath{path, headerType});
+}
+
+void ApiExtractorOptionsParser::parseIncludePathOption(const QStringList &values,
+                                                       HeaderType headerType)
+{
+    for (const auto &value : values)
+        parseIncludePathOption(value, headerType);
+}
+
+void ApiExtractorOptionsParser::setLanguageLevel(const QString &value)
+{
+    const QByteArray languageLevelBA = value.toLatin1();
+    const LanguageLevel level = clang::languageLevelFromOption(languageLevelBA.constData());
+    if (level == LanguageLevel::Default)
+        throw Exception(msgInvalidLanguageLevel(value));
+    m_options->m_languageLevel = level;
+}
+
+bool ApiExtractorOptionsParser::handleBoolOption(const QString &key, OptionSource source)
+{
+    static const auto isystemOption = "isystem"_L1;
+
+    switch (source) {
+    case OptionSource::CommandLine:
+    case OptionSource::ProjectFile:
+        if (key == u"use-global-header") {
+            AbstractMetaBuilder::setUseGlobalHeader(true);
+            return true;
+        }
+        if (key == u"skip-deprecated") {
+            m_options->m_skipDeprecated = true;
+            return true;
+        }
+        break;
+
+    case OptionSource::CommandLineSingleDash:
+        if (key.startsWith(u'I')) { // Shorthand path arguments -I/usr/include...
+            parseIncludePathOption(key.sliced(1), HeaderType::Standard);
+            return true;
+        }
+        if (key.startsWith(u'F')) {
+            parseIncludePathOption(key.sliced(1), HeaderType::Framework);
+            return true;
+        }
+        if (key.startsWith(isystemOption)) {
+            parseIncludePathOption(key.sliced(isystemOption.size()), HeaderType::System);
+            return true;
+        }
+        break;
+    }
+    return false;
+}
+
+bool ApiExtractorOptionsParser::handleOption(const QString &key, const QString &value,
+                                             OptionSource source)
+{
+    if (source == OptionSource::CommandLineSingleDash) {
+        if (key == u"std") {
+            setLanguageLevel(value);
+            return true;
+        }
+        return false;
+    }
+
+    if (key == u"clang-option") {
+        m_options->m_clangOptions.append(value);
+        return true;
+    }
+    if (key == u"clang-options") {
+        m_options->m_clangOptions.append(value.split(u',', Qt::SkipEmptyParts));
+        return true;
+    }
+    if (key == u"include-paths") {
+        parseIncludePathOption(value.split(QDir::listSeparator(), Qt::SkipEmptyParts),
+                               HeaderType::Standard);
+        return true;
+    }
+    if (key == u"framework-include-paths") {
+        parseIncludePathOption(value.split(QDir::listSeparator(), Qt::SkipEmptyParts),
+                               HeaderType::Framework);
+        return true;
+    }
+    if (key == u"system-include-paths") {
+        parseIncludePathOption(value.split(QDir::listSeparator(), Qt::SkipEmptyParts),
+                               HeaderType::System);
+        return true;
+    }
+    if (key == u"language-level") {
+        setLanguageLevel(value);
+        return true;
+    }
+
+    if (source == OptionSource::ProjectFile) {
+        if (key == u"include-path") {
+            parseIncludePathOption(value, HeaderType::Standard);
+            return true;
+        }
+        if (key == u"framework-include-path") {
+            parseIncludePathOption(value, HeaderType::Framework);
+            return true;
+        }
+        if (key == u"system-include-path") {
+            parseIncludePathOption(value, HeaderType::System);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+std::shared_ptr<OptionsParser> ApiExtractor::createOptionsParser()
+{
+    return std::make_shared<ApiExtractorOptionsParser>(d);
+}
+
+struct ApiExtractorPrivate : public ApiExtractorOptions
 {
     bool runHelper(ApiExtractorFlags flags);
 
@@ -54,7 +233,7 @@ struct ApiExtractorPrivate
     void collectInstantiatedContainersAndSmartPointers(InstantiationCollectContext &context,
                                                        const AbstractMetaFunctionCPtr &func);
     void collectInstantiatedContainersAndSmartPointers(InstantiationCollectContext &context,
-                                                       const AbstractMetaClass *metaClass);
+                                                       const AbstractMetaClassCPtr &metaClass);
     void collectInstantiatedContainersAndSmartPointers(InstantiationCollectContext &context);
     void collectInstantiatedOpqaqueContainers(InstantiationCollectContext &context);
     void collectContainerTypesFromSnippets(InstantiationCollectContext &context);
@@ -64,23 +243,12 @@ struct ApiExtractorPrivate
     void addInstantiatedSmartPointer(InstantiationCollectContext &context,
                                      const AbstractMetaType &type);
 
-    QString m_typeSystemFileName;
-    QFileInfoList m_cppFileNames;
-    HeaderPaths m_includePaths;
-    QStringList m_clangOptions;
     AbstractMetaBuilder *m_builder = nullptr;
-    QString m_logDirectory;
-    LanguageLevel m_languageLevel = LanguageLevel::Default;
-    bool m_skipDeprecated = false;
 };
 
 ApiExtractor::ApiExtractor() :
       d(new ApiExtractorPrivate)
 {
-    // Environment TYPESYSTEMPATH
-    QString envTypesystemPaths = QFile::decodeName(qgetenv("TYPESYSTEMPATH"));
-    if (!envTypesystemPaths.isEmpty())
-        TypeDatabase::instance()->addTypesystemPath(envTypesystemPaths);
 }
 
 ApiExtractor::~ApiExtractor()
@@ -89,32 +257,6 @@ ApiExtractor::~ApiExtractor()
     delete d;
 }
 
-void ApiExtractor::addTypesystemSearchPath (const QString& path)
-{
-    TypeDatabase::instance()->addTypesystemPath(path);
-}
-
-void ApiExtractor::addTypesystemSearchPath(const QStringList& paths)
-{
-    for (const QString &path : paths)
-        addTypesystemSearchPath(path);
-}
-
-void ApiExtractor::setTypesystemKeywords(const QStringList &keywords)
-{
-    TypeDatabase::instance()->setTypesystemKeywords(keywords);
-}
-
-void ApiExtractor::addIncludePath(const HeaderPath& path)
-{
-    d->m_includePaths << path;
-}
-
-void ApiExtractor::addIncludePath(const HeaderPaths& paths)
-{
-    d->m_includePaths << paths;
-}
-
 HeaderPaths ApiExtractor::includePaths() const
 {
     return d->m_includePaths;
@@ -145,33 +287,6 @@ QString ApiExtractor::typeSystem() const
     return d->m_typeSystemFileName;
 }
 
-void ApiExtractor::setSkipDeprecated(bool value)
-{
-    d->m_skipDeprecated = value;
-    if (d->m_builder)
-        d->m_builder->setSkipDeprecated(d->m_skipDeprecated);
-}
-
-void ApiExtractor::setSuppressWarnings ( bool value )
-{
-    TypeDatabase::instance()->setSuppressWarnings(value);
-}
-
-void ApiExtractor::setSilent ( bool value )
-{
-    ReportHandler::setSilent(value);
-}
-
-bool ApiExtractor::setApiVersion(const QString& package, const QString &version)
-{
-    return TypeDatabase::setApiVersion(package, version);
-}
-
-void ApiExtractor::setDropTypeEntries(const QStringList &dropEntries)
-{
-    TypeDatabase::instance()->setDropTypeEntries(dropEntries);
-}
-
 const AbstractMetaEnumList &ApiExtractor::globalEnums() const
 {
     Q_ASSERT(d->m_builder);
@@ -225,8 +340,7 @@ bool ApiExtractorPrivate::runHelper(ApiExtractorFlags flags)
     }
 
     const QString pattern = QDir::tempPath() + u'/'
-        + m_cppFileNames.constFirst().baseName()
-        + QStringLiteral("_XXXXXX.hpp");
+        + m_cppFileNames.constFirst().baseName() + "_XXXXXX.hpp"_L1;
     QTemporaryFile ppFile(pattern);
     bool autoRemove = !qEnvironmentVariableIsSet("KEEP_TEMP_FILES");
     // make sure that a tempfile can be written
@@ -266,16 +380,16 @@ bool ApiExtractorPrivate::runHelper(ApiExtractorFlags flags)
 
     for (const HeaderPath &headerPath : std::as_const(m_includePaths))
         arguments.append(HeaderPath::includeOption(headerPath));
+    if (flags.testFlag(ApiExtractorFlag::UsePySideExtensions))
+        addPySideExtensions(&arguments);
     arguments.append(QFile::encodeName(preprocessedCppFileName));
+
     if (ReportHandler::isDebug(ReportHandler::SparseDebug)) {
         qCInfo(lcShiboken).noquote().nospace()
             << "clang language level: " << int(m_languageLevel)
             << "\nclang arguments: " << arguments;
     }
 
-    if (flags.testFlag(ApiExtractorFlag::UsePySideExtensions))
-        addPySideExtensions(&arguments);
-
     const bool result = m_builder->build(arguments, flags, addCompilerSupportArguments,
                                          m_languageLevel);
     if (!result)
@@ -300,18 +414,17 @@ std::optional<ApiExtractorResult> ApiExtractor::run(ApiExtractorFlags flags)
     InstantiationCollectContext collectContext;
     d->collectInstantiatedContainersAndSmartPointers(collectContext);
 
-    auto *data = new ApiExtractorResultData;
-
-    classListToCList(d->m_builder->takeClasses(), &data->m_metaClasses);
-    classListToCList(d->m_builder->takeTemplates(), &data->m_templates);
-    classListToCList(d->m_builder->takeSmartPointers(), &data->m_smartPointers);
-    data->m_globalFunctions = d->m_builder->globalFunctions();
-    data->m_globalEnums = d->m_builder->globalEnums();
-    data->m_enums = d->m_builder->typeEntryToEnumsHash();
-    data->m_flags = flags;
-    qSwap(data->m_instantiatedContainers, collectContext.instantiatedContainers);
-    qSwap(data->m_instantiatedSmartPointers, collectContext.instantiatedSmartPointers);
-    return ApiExtractorResult(data);
+    ApiExtractorResult result;
+    classListToCList(d->m_builder->takeClasses(), &result.m_metaClasses);
+    classListToCList(d->m_builder->takeSmartPointers(), &result.m_smartPointers);
+    result.m_globalFunctions = d->m_builder->globalFunctions();
+    result.m_globalEnums = d->m_builder->globalEnums();
+    result.m_enums = d->m_builder->typeEntryToEnumsHash();
+    result.m_flags = flags;
+    result.m_typedefTargetToName = d->m_builder->typedefTargetToName();
+    qSwap(result.m_instantiatedContainers, collectContext.instantiatedContainers);
+    qSwap(result.m_instantiatedSmartPointers, collectContext.instantiatedSmartPointers);
+    return result;
 }
 
 LanguageLevel ApiExtractor::languageLevel() const
@@ -319,26 +432,11 @@ LanguageLevel ApiExtractor::languageLevel() const
     return d->m_languageLevel;
 }
 
-void ApiExtractor::setLanguageLevel(LanguageLevel languageLevel)
-{
-    d->m_languageLevel = languageLevel;
-}
-
 QStringList ApiExtractor::clangOptions() const
 {
     return d->m_clangOptions;
 }
 
-void ApiExtractor::setClangOptions(const QStringList &co)
-{
-    d->m_clangOptions = co;
-}
-
-void ApiExtractor::setUseGlobalHeader(bool h)
-{
-    AbstractMetaBuilder::setUseGlobalHeader(h);
-}
-
 AbstractMetaFunctionPtr
     ApiExtractor::inheritTemplateFunction(const AbstractMetaFunctionCPtr &function,
                                           const AbstractMetaTypeList &templateTypes)
@@ -349,20 +447,19 @@ AbstractMetaFunctionPtr
 AbstractMetaFunctionPtr
     ApiExtractor::inheritTemplateMember(const AbstractMetaFunctionCPtr &function,
                                         const AbstractMetaTypeList &templateTypes,
-                                        const AbstractMetaClass *templateClass,
-                                        AbstractMetaClass *subclass)
+                                        const AbstractMetaClassCPtr &templateClass,
+                                        const AbstractMetaClassPtr &subclass)
 {
     return AbstractMetaBuilder::inheritTemplateMember(function, templateTypes,
                                                       templateClass, subclass);
 }
 
-AbstractMetaClass *ApiExtractor::inheritTemplateClass(const ComplexTypeEntryPtr &te,
-                                                      const AbstractMetaClass *templateClass,
-                                                      const AbstractMetaTypeList &templateTypes,
-                                                      InheritTemplateFlags flags)
+AbstractMetaClassPtr ApiExtractor::inheritTemplateClass(const ComplexTypeEntryPtr &te,
+                                                      const AbstractMetaClassCPtr &templateClass,
+                                                      const AbstractMetaTypeList &templateTypes)
 {
     return AbstractMetaBuilder::inheritTemplateClass(te, templateClass,
-                                                     templateTypes, flags);
+                                                     templateTypes);
 }
 
 QString ApiExtractorPrivate::getSimplifiedContainerTypeName(const AbstractMetaType &type)
@@ -436,12 +533,12 @@ ApiExtractorPrivate::addInstantiatedContainersAndSmartPointers(InstantiationColl
         return;
     }
     if (type.hasTemplateChildren()) {
-        QString piece = isContainer ? QStringLiteral("container") : QStringLiteral("smart pointer");
+        const auto piece = isContainer ? "container"_L1 : "smart pointer"_L1;
         QString warning =
             QString::fromLatin1("Skipping instantiation of %1 '%2' because it has template"
                                 " arguments.").arg(piece, type.originalTypeDescription());
         if (!contextName.isEmpty())
-            warning.append(QStringLiteral(" Calling context: ") + contextName);
+            warning.append(" Calling context: "_L1 + contextName);
 
         qCWarning(lcShiboken).noquote().nospace() << warning;
         return;
@@ -489,7 +586,7 @@ static void addOwnerModification(const AbstractMetaFunctionCList &functions,
     for (const auto &f : functions) {
         if (!f->arguments().isEmpty()
             && f->arguments().constFirst().type().indirections() > 0) {
-            qSharedPointerConstCast<AbstractMetaFunction>(f)->clearModificationsCache();
+            std::const_pointer_cast<AbstractMetaFunction>(f)->clearModificationsCache();
             typeEntry->addFunctionModification(invalidateArgMod(f));
         }
     }
@@ -505,10 +602,18 @@ void ApiExtractorPrivate::addInstantiatedSmartPointer(InstantiationCollectContex
     Q_ASSERT(smp.smartPointer);
 
     const auto &instantiatedType = type.instantiations().constFirst();
-    const auto ste = qSharedPointerCast<const SmartPointerTypeEntry>(smp.smartPointer->typeEntry());
+    const auto ste = std::static_pointer_cast<const SmartPointerTypeEntry>(smp.smartPointer->typeEntry());
     QString name = ste->getTargetName(smp.type);
     auto parentTypeEntry = ste->parent();
-    InheritTemplateFlags flags;
+
+    // FIXME PYSIDE 7: Make global scope the default behavior?
+    // Note: Also requires changing SmartPointerTypeEntry::getTargetName()
+    // to not strip namespaces from unnamed instances.
+    const bool globalScope = name.startsWith("::"_L1);
+    if (globalScope) {
+        name.remove(0, 2);
+        parentTypeEntry = typeSystemTypeEntry(ste);
+    }
 
     auto colonPos = name.lastIndexOf(u"::");
     const bool withinNameSpace = colonPos != -1;
@@ -519,22 +624,21 @@ void ApiExtractorPrivate::addInstantiatedSmartPointer(InstantiationCollectContex
         if (nameSpaces.isEmpty())
             throw Exception(msgNamespaceNotFound(name));
         parentTypeEntry = nameSpaces.constFirst();
-    } else {
-        flags.setFlag(InheritTemplateFlag::SetEnclosingClass);
     }
 
     TypedefEntryPtr typedefEntry(new TypedefEntry(name, ste->name(), ste->version(),
                                                   parentTypeEntry));
     typedefEntry->setTargetLangPackage(ste->targetLangPackage());
     auto instantiationEntry = TypeDatabase::initializeTypeDefEntry(typedefEntry, ste);
+    instantiationEntry->setParent(parentTypeEntry);
 
     smp.specialized = ApiExtractor::inheritTemplateClass(instantiationEntry, smp.smartPointer,
-                                                         {instantiatedType}, flags);
+                                                         {instantiatedType});
     Q_ASSERT(smp.specialized);
-    if (withinNameSpace) { // move class to desired namespace
-        auto *enclClass = AbstractMetaClass::findClass(m_builder->classes(), parentTypeEntry);
+    if (parentTypeEntry->type() != TypeEntry::TypeSystemType) { // move class to desired namespace
+        const auto enclClass = AbstractMetaClass::findClass(m_builder->classes(), parentTypeEntry);
         Q_ASSERT(enclClass);
-        auto *specialized = const_cast<AbstractMetaClass *>(smp.specialized);
+        auto specialized = std::const_pointer_cast<AbstractMetaClass>(smp.specialized);
         specialized->setEnclosingClass(enclClass);
         enclClass->addInnerClass(specialized);
     }
@@ -556,26 +660,31 @@ ApiExtractorPrivate::collectInstantiatedContainersAndSmartPointers(Instantiation
                                                                    const AbstractMetaFunctionCPtr &func)
 {
     addInstantiatedContainersAndSmartPointers(context, func->type(), func->signature());
-    for (const AbstractMetaArgument &arg : func->arguments())
-        addInstantiatedContainersAndSmartPointers(context, arg.type(), func->signature());
+    for (const AbstractMetaArgument &arg : func->arguments()) {
+        const auto argType = arg.type();
+        const auto type = argType.viewOn() != nullptr ? *argType.viewOn() : argType;
+        addInstantiatedContainersAndSmartPointers(context, type, func->signature());
+    }
 }
 
 void
 ApiExtractorPrivate::collectInstantiatedContainersAndSmartPointers(InstantiationCollectContext &context,
-                                                                   const AbstractMetaClass *metaClass)
+                                                                   const AbstractMetaClassCPtr &metaClass)
 {
     if (!metaClass->typeEntry()->generateCode())
         return;
     for (const auto &func : metaClass->functions())
         collectInstantiatedContainersAndSmartPointers(context, func);
+    for (const auto &func : metaClass->userAddedPythonOverrides())
+        collectInstantiatedContainersAndSmartPointers(context, func);
     for (const AbstractMetaField &field : metaClass->fields())
         addInstantiatedContainersAndSmartPointers(context, field.type(), field.name());
 
     // The list of inner classes might be extended when smart pointer
     // instantiations are specified to be in namespaces.
-    auto &innerClasses = metaClass->innerClasses();
+    const auto &innerClasses = metaClass->innerClasses();
     for (auto i = innerClasses.size() - 1; i >= 0; --i) {
-         auto *innerClass = innerClasses.at(i);
+         const auto innerClass = innerClasses.at(i);
          if (!innerClass->typeEntry()->isSmartPointer())
              collectInstantiatedContainersAndSmartPointers(context, innerClass);
     }
@@ -587,7 +696,7 @@ ApiExtractorPrivate::collectInstantiatedContainersAndSmartPointers(Instantiation
     collectInstantiatedOpqaqueContainers(context);
     for (const auto &func : m_builder->globalFunctions())
         collectInstantiatedContainersAndSmartPointers(context, func);
-    for (auto metaClass : m_builder->classes())
+    for (const auto &metaClass : m_builder->classes())
         collectInstantiatedContainersAndSmartPointers(context, metaClass);
     collectContainerTypesFromSnippets(context);
 }
@@ -614,8 +723,7 @@ void ApiExtractorPrivate::collectInstantiatedOpqaqueContainers(InstantiationColl
     for (const auto &container : containers) {
         for (const auto &oc : container->opaqueContainers()) {
             QString errorMessage;
-            const QString typeName = container->qualifiedCppName() + u'<'
-                                     + oc.instantiation + u'>';
+            const QString typeName = container->qualifiedCppName() + oc.templateParameters();
             auto typeOpt = AbstractMetaType::fromString(typeName, &errorMessage);
             if (typeOpt.has_value()
                 && generateOpaqueContainer(typeOpt.value(), moduleEntry)) {
@@ -635,12 +743,12 @@ static void getCode(QStringList &code, const CodeSnipList &codeSnips)
 static void getCode(QStringList &code, const TypeEntryCPtr &type)
 {
     if (type->isComplex())
-        getCode(code, qSharedPointerCast<const ComplexTypeEntry>(type)->codeSnips());
+        getCode(code, std::static_pointer_cast<const ComplexTypeEntry>(type)->codeSnips());
     else if (type->isTypeSystem())
-        getCode(code, qSharedPointerCast<const TypeSystemTypeEntry>(type)->codeSnips());
+        getCode(code, std::static_pointer_cast<const TypeSystemTypeEntry>(type)->codeSnips());
 
     auto customConversion = CustomConversion::getCustomConversion(type);
-    if (customConversion.isNull())
+    if (!customConversion)
         return;
 
     if (!customConversion->nativeToTargetConversion().isEmpty())
@@ -664,11 +772,11 @@ void ApiExtractorPrivate::collectContainerTypesFromSnippets(InstantiationCollect
     const ContainerTypeEntryCList &containerTypeList = td->containerTypes();
     for (const auto &type : containerTypeList)
         getCode(snips, type);
-    for (auto metaClass : m_builder->classes())
+    for (const auto &metaClass : m_builder->classes())
         getCode(snips, metaClass->typeEntry());
 
     const auto moduleEntry = td->defaultTypeSystemType();
-    Q_ASSERT(!moduleEntry.isNull());
+    Q_ASSERT(moduleEntry);
     getCode(snips, moduleEntry);
 
     for (const auto &func : m_builder->globalFunctions())
@@ -686,8 +794,8 @@ ApiExtractorPrivate::collectContainerTypesFromConverterMacros(InstantiationColle
                                                               bool toPythonMacro)
 {
     QString convMacro = toPythonMacro ? u"%CONVERTTOPYTHON["_s : u"%CONVERTTOCPP["_s;
-    int offset = toPythonMacro ? sizeof("%CONVERTTOPYTHON") : sizeof("%CONVERTTOCPP");
-    int start = 0;
+    const qsizetype offset = toPythonMacro ? sizeof("%CONVERTTOPYTHON") : sizeof("%CONVERTTOCPP");
+    qsizetype start = 0;
     QString errorMessage;
     while ((start = code.indexOf(convMacro, start)) != -1) {
         int end = code.indexOf(u']', start);
diff --git a/sources/shiboken6/ApiExtractor/apiextractor.h b/sources/shiboken6/ApiExtractor/apiextractor.h
index 51df5e45a..7bff5c252 100644
--- a/sources/shiboken6/ApiExtractor/apiextractor.h
+++ b/sources/shiboken6/ApiExtractor/apiextractor.h
@@ -20,6 +20,8 @@ class AbstractMetaClass;
 class AbstractMetaEnum;
 class AbstractMetaFunction;
 class ComplexTypeEntry;
+struct OptionDescription;
+class OptionsParser;
 
 QT_BEGIN_NAMESPACE
 class QDebug;
@@ -36,27 +38,17 @@ public:
     ApiExtractor();
     ~ApiExtractor();
 
+    static QList<OptionDescription> options();
+    std::shared_ptr<OptionsParser> createOptionsParser();
+
     void setTypeSystem(const QString& typeSystemFileName);
     QString typeSystem() const;
     void setCppFileNames(const QFileInfoList &cppFileNames);
     QFileInfoList cppFileNames() const;
-    void setSkipDeprecated(bool value);
-    static void setSuppressWarnings(bool value);
-    static void setSilent(bool value);
-    static void addTypesystemSearchPath(const QString &path);
-    static void addTypesystemSearchPath(const QStringList& paths);
-    static void setTypesystemKeywords(const QStringList& keywords);
-    void addIncludePath(const HeaderPath& path);
-    void addIncludePath(const HeaderPaths& paths);
     HeaderPaths includePaths() const;
     void setLogDirectory(const QString& logDir);
-    static bool setApiVersion(const QString &package, const QString &version);
-    static void setDropTypeEntries(const QStringList &dropEntries);
     LanguageLevel languageLevel() const;
-    void setLanguageLevel(LanguageLevel languageLevel);
     QStringList clangOptions() const;
-    void setClangOptions(const QStringList &co);
-    static void setUseGlobalHeader(bool h);
 
     const AbstractMetaEnumList &globalEnums() const;
     const AbstractMetaFunctionCList &globalFunctions() const;
@@ -74,15 +66,14 @@ public:
     static AbstractMetaFunctionPtr
         inheritTemplateMember(const AbstractMetaFunctionCPtr &function,
                               const AbstractMetaTypeList &templateTypes,
-                              const AbstractMetaClass *templateClass,
-                              AbstractMetaClass *subclass);
+                              const AbstractMetaClassCPtr &templateClass,
+                              const AbstractMetaClassPtr &subclass);
 
     /// Forwards to AbstractMetaBuilder::inheritTemplateClass()
-    static AbstractMetaClass *
+    static AbstractMetaClassPtr
         inheritTemplateClass(const ComplexTypeEntryPtr &te,
-                             const AbstractMetaClass *templateClass,
-                             const AbstractMetaTypeList &templateTypes,
-                             InheritTemplateFlags flags = {});
+                             const AbstractMetaClassCPtr &templateClass,
+                             const AbstractMetaTypeList &templateTypes);
 
 private:
     ApiExtractorPrivate *d;
diff --git a/sources/shiboken6/ApiExtractor/apiextractorflags.h b/sources/shiboken6/ApiExtractor/apiextractorflags.h
index 4fe6ecc1a..6f69b8b77 100644
--- a/sources/shiboken6/ApiExtractor/apiextractorflags.h
+++ b/sources/shiboken6/ApiExtractor/apiextractorflags.h
@@ -15,12 +15,4 @@ enum class ApiExtractorFlag
 Q_DECLARE_FLAGS(ApiExtractorFlags, ApiExtractorFlag)
 Q_DECLARE_OPERATORS_FOR_FLAGS(ApiExtractorFlags)
 
-enum class InheritTemplateFlag
-{
-    SetEnclosingClass = 0x1
-};
-
-Q_DECLARE_FLAGS(InheritTemplateFlags, InheritTemplateFlag)
-Q_DECLARE_OPERATORS_FOR_FLAGS(InheritTemplateFlags)
-
 #endif // APIEXTRACTORFLAGS_H
diff --git a/sources/shiboken6/ApiExtractor/apiextractorresult.cpp b/sources/shiboken6/ApiExtractor/apiextractorresult.cpp
index a0917d64e..b53ffa9b6 100644
--- a/sources/shiboken6/ApiExtractor/apiextractorresult.cpp
+++ b/sources/shiboken6/ApiExtractor/apiextractorresult.cpp
@@ -2,90 +2,88 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "apiextractorresult.h"
-#include "apiextractorresultdata_p.h"
 #include "abstractmetalang.h"
 #include "abstractmetaenum.h"
 
 #include "enumtypeentry.h"
 #include "flagstypeentry.h"
 
-ApiExtractorResultData::ApiExtractorResultData() = default;
-
-ApiExtractorResultData::~ApiExtractorResultData()
-{
-    qDeleteAll(m_smartPointers);
-    qDeleteAll(m_metaClasses);
-    qDeleteAll(m_templates);
-    for (auto &smp : m_instantiatedSmartPointers)
-        delete smp.specialized;
-}
-
-ApiExtractorResult::ApiExtractorResult() : d(new ApiExtractorResultData)
-{
-}
-
-ApiExtractorResult::ApiExtractorResult(ApiExtractorResultData *data) :
-    d(data)
-{
-}
+ApiExtractorResult::ApiExtractorResult() = default;
 
 ApiExtractorResult::ApiExtractorResult(const ApiExtractorResult &) = default;
 
 ApiExtractorResult &ApiExtractorResult::operator=(const ApiExtractorResult &) = default;
 
-ApiExtractorResult::ApiExtractorResult(ApiExtractorResult &&) = default;
+ApiExtractorResult::ApiExtractorResult(ApiExtractorResult &&) noexcept = default;
 
-ApiExtractorResult &ApiExtractorResult::operator=(ApiExtractorResult &&) = default;
+ApiExtractorResult &ApiExtractorResult::operator=(ApiExtractorResult &&) noexcept = default;
 
 ApiExtractorResult::~ApiExtractorResult() = default;
 
 const AbstractMetaEnumList &ApiExtractorResult::globalEnums() const
 {
-    return d->m_globalEnums;
+    return m_globalEnums;
 }
 
 const AbstractMetaFunctionCList &ApiExtractorResult::globalFunctions() const
 {
-    return d->m_globalFunctions;
+    return m_globalFunctions;
 }
 
 const AbstractMetaClassCList &ApiExtractorResult::classes() const
 {
-    return d->m_metaClasses;
+    return m_metaClasses;
 }
 
 const AbstractMetaClassCList &ApiExtractorResult::smartPointers() const
 {
-    return d->m_smartPointers;
+    return m_smartPointers;
 }
 
 const AbstractMetaTypeList &ApiExtractorResult::instantiatedContainers() const
 {
-    return d->m_instantiatedContainers;
+    return m_instantiatedContainers;
 }
 
 const InstantiatedSmartPointers &ApiExtractorResult::instantiatedSmartPointers() const
 {
-    return d->m_instantiatedSmartPointers;
+    return m_instantiatedSmartPointers;
+}
+
+std::optional<InstantiatedSmartPointer>
+    ApiExtractorResult::findSmartPointerInstantiation(const SmartPointerTypeEntryCPtr &pointer,
+                                                      const TypeEntryCPtr &pointee) const
+{
+    for (const auto &smp : m_instantiatedSmartPointers) {
+        const auto &i = smp.type;
+        if (i.typeEntry() == pointer && i.instantiations().at(0).typeEntry() == pointee)
+            return smp;
+    }
+    return std::nullopt;
+}
+
+const QMultiHash<QString, QString> &ApiExtractorResult::typedefTargetToName() const
+{
+    return m_typedefTargetToName;
 }
 
 ApiExtractorFlags ApiExtractorResult::flags() const
 {
-    return d->m_flags;
+    return m_flags;
 }
 
 void ApiExtractorResult::setFlags(ApiExtractorFlags f)
 {
-    d->m_flags = f;
+    m_flags = f;
 }
 
 std::optional<AbstractMetaEnum>
     ApiExtractorResult::findAbstractMetaEnum(TypeEntryCPtr typeEntry) const
 {
-    if (!typeEntry.isNull() && typeEntry->isFlags())
-        typeEntry = qSharedPointerCast<const FlagsTypeEntry>(typeEntry)->originator();
-    const auto it = d->m_enums.constFind(typeEntry);
-    if (it == d->m_enums.constEnd())
+    if (typeEntry && typeEntry->isFlags())
+        typeEntry = std::static_pointer_cast<const FlagsTypeEntry>(typeEntry)->originator();
+    const auto it = m_enums.constFind(typeEntry);
+    if (it == m_enums.constEnd())
         return {};
     return it.value();
 }
@@ -93,7 +91,7 @@ std::optional<AbstractMetaEnum>
 AbstractMetaFunctionCList ApiExtractorResult::implicitConversions(const TypeEntryCPtr &type) const
 {
     if (type->isValue()) {
-        if (auto metaClass = AbstractMetaClass::findClass(d->m_metaClasses, type))
+        if (auto metaClass = AbstractMetaClass::findClass(m_metaClasses, type))
             return metaClass->implicitConversions();
     }
     return {};
diff --git a/sources/shiboken6/ApiExtractor/apiextractorresult.h b/sources/shiboken6/ApiExtractor/apiextractorresult.h
index f85fca9f0..b2aae88ed 100644
--- a/sources/shiboken6/ApiExtractor/apiextractorresult.h
+++ b/sources/shiboken6/ApiExtractor/apiextractorresult.h
@@ -9,7 +9,8 @@
 #include "abstractmetalang_typedefs.h"
 #include "typesystem_typedefs.h"
 
-#include <QtCore/QExplicitlySharedDataPointer>
+#include <QtCore/QHash>
+#include <QtCore/QMultiHash>
 
 #include <optional>
 
@@ -17,8 +18,8 @@ class ApiExtractorResultData;
 
 struct InstantiatedSmartPointer
 {
-    const AbstractMetaClass *smartPointer = nullptr; // Template class
-    const AbstractMetaClass *specialized = nullptr; // Specialized for type
+    AbstractMetaClassCPtr smartPointer; // Template class
+    AbstractMetaClassCPtr specialized; // Specialized for type
     AbstractMetaType type;
 };
 
@@ -29,11 +30,10 @@ class ApiExtractorResult
 {
 public:
     ApiExtractorResult();
-    explicit ApiExtractorResult(ApiExtractorResultData *data);
     ApiExtractorResult(const ApiExtractorResult &);
     ApiExtractorResult &operator=(const ApiExtractorResult &);
-    ApiExtractorResult(ApiExtractorResult &&);
-    ApiExtractorResult &operator=(ApiExtractorResult &&);
+    ApiExtractorResult(ApiExtractorResult &&) noexcept;
+    ApiExtractorResult &operator=(ApiExtractorResult &&) noexcept;
     ~ApiExtractorResult();
 
     const AbstractMetaEnumList &globalEnums() const;
@@ -43,6 +43,11 @@ public:
 
     const AbstractMetaTypeList &instantiatedContainers() const;
     const InstantiatedSmartPointers &instantiatedSmartPointers() const;
+    std::optional<InstantiatedSmartPointer>
+        findSmartPointerInstantiation(const SmartPointerTypeEntryCPtr &pointer,
+                                      const TypeEntryCPtr &pointee) const;
+
+    const QMultiHash<QString, QString> &typedefTargetToName() const;
 
     // Query functions for the generators
     std::optional<AbstractMetaEnum>
@@ -60,7 +65,17 @@ public:
     void setFlags(ApiExtractorFlags f);
 
 private:
-    QExplicitlySharedDataPointer<ApiExtractorResultData> d;
+    AbstractMetaClassCList m_metaClasses;
+    AbstractMetaClassCList m_smartPointers;
+    AbstractMetaFunctionCList m_globalFunctions;
+    AbstractMetaEnumList m_globalEnums;
+    AbstractMetaTypeList m_instantiatedContainers;
+    InstantiatedSmartPointers m_instantiatedSmartPointers;
+    QHash<TypeEntryCPtr, AbstractMetaEnum> m_enums;
+    QMultiHash<QString, QString> m_typedefTargetToName;
+    ApiExtractorFlags m_flags;
+
+    friend class ApiExtractor;
 };
 
 #endif // APIEXTRACTORRESULT_H
diff --git a/sources/shiboken6/ApiExtractor/apiextractorresultdata_p.h b/sources/shiboken6/ApiExtractor/apiextractorresultdata_p.h
deleted file mode 100644
index 05d548d6d..000000000
--- a/sources/shiboken6/ApiExtractor/apiextractorresultdata_p.h
+++ /dev/null
@@ -1,29 +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
-
-#ifndef APIEXTRACTORRESULTDATA_P_H
-#define APIEXTRACTORRESULTDATA_P_H
-
-#include "apiextractorresult.h"
-
-#include <QtCore/QHash>
-#include <QtCore/QSharedData>
-
-class ApiExtractorResultData : public QSharedData
-{
-public:
-    ApiExtractorResultData();
-    ~ApiExtractorResultData();
-
-    AbstractMetaClassCList m_metaClasses;
-    AbstractMetaClassCList m_templates; // not exposed, just for ownership
-    AbstractMetaClassCList m_smartPointers;
-    AbstractMetaFunctionCList m_globalFunctions;
-    AbstractMetaEnumList m_globalEnums;
-    AbstractMetaTypeList m_instantiatedContainers;
-    InstantiatedSmartPointers m_instantiatedSmartPointers;
-    QHash<TypeEntryCPtr, AbstractMetaEnum> m_enums;
-    ApiExtractorFlags m_flags;
-};
-
-#endif // APIEXTRACTORRESULTDATA_P_H
diff --git a/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.cpp b/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.cpp
index 512f1a879..31e7efb05 100644
--- a/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.cpp
+++ b/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.cpp
@@ -4,6 +4,7 @@
 #include "clangbuilder.h"
 #include "compilersupport.h"
 #include "clangutils.h"
+#include "clangdebugutils.h"
 
 #include <codemodel.h>
 #include <reporthandler.h>
@@ -25,9 +26,6 @@ using namespace Qt::StringLiterals;
 
 namespace clang {
 
-static inline QString colonColon() { return QStringLiteral("::"); }
-static inline QString templateBrackets() { return QStringLiteral("<>"); }
-
 static inline bool isClassCursor(const CXCursor &c)
 {
     return c.kind == CXCursor_ClassDecl || c.kind == CXCursor_StructDecl
@@ -115,8 +113,17 @@ static bool isSigned(CXTypeKind kind)
 
 class BuilderPrivate {
 public:
+    Q_DISABLE_COPY_MOVE(BuilderPrivate)
+
+    enum class SpecialSystemHeader {
+        None,
+        Types,
+        OpenGL,
+        WhiteListed,
+        WhiteListedPath
+    };
+
     using CursorClassHash = QHash<CXCursor, ClassModelItem>;
-    using CursorTypedefHash = QHash<CXCursor, TypeDefModelItem>;
     using TypeInfoHash = QHash<CXType, TypeInfo>;
 
     explicit BuilderPrivate(BaseVisitor *bv) : m_baseVisitor(bv), m_model(new CodeModel)
@@ -182,10 +189,9 @@ public:
     std::pair<QString, ClassModelItem> getBaseClass(CXType type) const;
     void addBaseClass(const CXCursor &cursor);
 
-    template <class Item>
-    void qualifyTypeDef(const CXCursor &typeRefCursor, const QSharedPointer<Item> &item) const;
-
+    SpecialSystemHeader specialSystemHeader(const QString &fileName) const;
     bool visitHeader(const QString &fileName) const;
+    static const char *specialSystemHeaderReason(SpecialSystemHeader sh);
 
     void setFileName(const CXCursor &cursor, _CodeModelItem *item);
 
@@ -198,7 +204,6 @@ public:
     // classes can be correctly parented in case of forward-declared inner classes
     // (QMetaObject::Connection)
     CursorClassHash m_cursorClassHash;
-    CursorTypedefHash m_cursorTypedefHash;
 
     mutable TypeInfoHash m_typeInfoHash; // Cache type information
     mutable QHash<QString, TemplateTypeAliasModelItem> m_templateTypeAliases;
@@ -209,21 +214,22 @@ public:
     ArgumentModelItem m_currentArgument;
     VariableModelItem m_currentField;
     TemplateTypeAliasModelItem m_currentTemplateTypeAlias;
-    QStringList m_systemIncludes; // files, like "memory"
-    QStringList m_systemIncludePaths; // paths, like "/usr/include/Qt/"
+    QStringList m_forceProcessSystemIncludes; // files, like "memory"
+    QStringList m_forceProcessSystemIncludePaths; // paths, like "/usr/include/Qt/"
     QString m_usingTypeRef; // Base classes in "using Base::member;"
     bool m_withinUsingDeclaration = false;
 
     int m_anonymousEnumCount = 0;
     CodeModel::FunctionType m_currentFunctionType = CodeModel::Normal;
     bool m_withinFriendDecl = false;
+    mutable QHash<QString, SpecialSystemHeader> m_systemHeaders;
 };
 
 bool BuilderPrivate::addClass(const CXCursor &cursor, CodeModel::ClassType t)
 {
     QString className = getCursorSpelling(cursor);
     m_currentClass.reset(new _ClassModelItem(m_model, className));
-    setFileName(cursor, m_currentClass.data());
+    setFileName(cursor, m_currentClass.get());
     m_currentClass->setClassType(t);
     // Some inner class? Note that it does not need to be (lexically) contained in a
     // class since it is possible to forward declare an inner class:
@@ -266,7 +272,7 @@ static QString msgCannotDetermineException(const std::string_view &snippetV)
     const qsizetype length = qsizetype(truncate ? newLine : snippetV.size());
     QString snippet = QString::fromUtf8(snippetV.data(), length);
     if (truncate)
-        snippet += QStringLiteral("...");
+        snippet += "..."_L1;
 
     return u"Cannot determine exception specification: \""_s + snippet + u'"';
 }
@@ -327,9 +333,11 @@ FunctionModelItem BuilderPrivate::createFunction(const CXCursor &cursor,
     // Apply type fixes to "operator X &" -> "operator X&"
     if (name.startsWith(u"operator "))
         name = fixTypeName(name);
-    FunctionModelItem result(new _FunctionModelItem(m_model, name));
-    setFileName(cursor, result.data());
-    result->setType(createTypeInfo(clang_getCursorResultType(cursor)));
+    auto result = std::make_shared<_FunctionModelItem>(m_model, name);
+    setFileName(cursor, result.get());
+    const auto type = clang_getCursorResultType(cursor);
+    result->setType(createTypeInfo(type));
+    result->setScopeResolution(hasScopeResolution(type));
     result->setFunctionType(t);
     result->setScope(m_scope);
     result->setStatic(clang_Cursor_getStorageClass(cursor) == CX_SC_Static);
@@ -338,7 +346,7 @@ FunctionModelItem BuilderPrivate::createFunction(const CXCursor &cursor,
     case CXAvailability_Available:
         break;
     case CXAvailability_Deprecated:
-        result->setDeprecated(true);
+        result->setAttribute(FunctionAttribute::Deprecated);
         break;
     case CXAvailability_NotAvailable: // "Foo(const Foo&) = delete;"
         result->setDeleted(true);
@@ -381,9 +389,9 @@ FunctionModelItem BuilderPrivate::createMemberFunction(const CXCursor &cursor,
     auto result = createFunction(cursor, functionType, isTemplateCode);
     result->setAccessPolicy(accessPolicy(clang_getCXXAccessSpecifier(cursor)));
     result->setConstant(clang_CXXMethod_isConst(cursor) != 0);
-    result->setStatic(clang_CXXMethod_isStatic(cursor) != 0);
-    result->setVirtual(clang_CXXMethod_isVirtual(cursor) != 0);
-    result->setAbstract(clang_CXXMethod_isPureVirtual(cursor) != 0);
+    result->setAttribute(FunctionAttribute::Static, clang_CXXMethod_isStatic(cursor) != 0);
+    result->setAttribute(FunctionAttribute::Virtual, clang_CXXMethod_isVirtual(cursor) != 0);
+    result->setAttribute(FunctionAttribute::Abstract, clang_CXXMethod_isPureVirtual(cursor) != 0);
     return result;
 }
 
@@ -399,13 +407,14 @@ void BuilderPrivate::qualifyConstructor(const CXCursor &cursor)
         && m_currentFunction->arguments().size() == 1
         && clang_CXXConstructor_isCopyConstructor(cursor) == 0
         && clang_CXXConstructor_isMoveConstructor(cursor) == 0) {
-        m_currentFunction->setExplicit(clang_CXXConstructor_isConvertingConstructor(cursor) == 0);
+        m_currentFunction->setAttribute(FunctionAttribute::Explicit,
+                                        clang_CXXConstructor_isConvertingConstructor(cursor) == 0);
     }
 }
 
 TemplateParameterModelItem BuilderPrivate::createTemplateParameter(const CXCursor &cursor) const
 {
-    return TemplateParameterModelItem(new _TemplateParameterModelItem(m_model, getCursorSpelling(cursor)));
+    return std::make_shared<_TemplateParameterModelItem>(m_model, getCursorSpelling(cursor));
 }
 
 TemplateParameterModelItem BuilderPrivate::createNonTypeTemplateParameter(const CXCursor &cursor) const
@@ -418,11 +427,12 @@ TemplateParameterModelItem BuilderPrivate::createNonTypeTemplateParameter(const
 // CXCursor_VarDecl, CXCursor_FieldDecl cursors
 void BuilderPrivate::addField(const CXCursor &cursor)
 {
-    VariableModelItem field(new _VariableModelItem(m_model, getCursorSpelling(cursor)));
+    auto field = std::make_shared<_VariableModelItem>(m_model, getCursorSpelling(cursor));
     field->setAccessPolicy(accessPolicy(clang_getCXXAccessSpecifier(cursor)));
     field->setScope(m_scope);
     field->setType(createTypeInfo(cursor));
     field->setMutable(clang_CXXField_isMutable(cursor) != 0);
+    setFileName(cursor, field.get());
     m_currentField = field;
     m_scopeStack.back()->addVariable(field);
 }
@@ -438,7 +448,7 @@ static QStringList qualifiedName(const QString &t)
         end = t.size();
     int lastPos = 0;
     while (true) {
-        const int nextPos = t.indexOf(colonColon(), lastPos);
+        const int nextPos = t.indexOf(u"::"_s, lastPos);
         if (nextPos < 0 || nextPos >= end)
             break;
         result.append(t.mid(lastPos, nextPos - lastPos));
@@ -556,7 +566,7 @@ TypeInfo BuilderPrivate::createTypeInfoUncached(const CXType &type,
     typeInfo.setConstant(clang_isConstQualifiedType(nestedType) != 0);
     typeInfo.setVolatile(clang_isVolatileQualifiedType(nestedType) != 0);
 
-    QString typeName = getTypeName(nestedType);
+    QString typeName = getResolvedTypeName(nestedType);
     while (TypeInfo::stripLeadingConst(&typeName)
            || TypeInfo::stripLeadingVolatile(&typeName)) {
     }
@@ -566,14 +576,14 @@ TypeInfo BuilderPrivate::createTypeInfoUncached(const CXType &type,
     // the typedef source is named "type-parameter-0-0". Convert it back to the
     // template parameter name. The CXTypes are the same for all templates and
     // must not be cached.
-    if (!m_currentClass.isNull() && typeName.startsWith(u"type-parameter-0-")) {
+    if (m_currentClass && typeName.startsWith(u"type-parameter-0-")) {
         if (cacheable != nullptr)
             *cacheable = false;
         bool ok;
         const int n = QStringView{typeName}.mid(17).toInt(&ok);
         if (ok) {
             auto currentTemplate = currentTemplateClass();
-            if (!currentTemplate.isNull() && n < currentTemplate->templateParameters().size())
+            if (currentTemplate && n < currentTemplate->templateParameters().size())
                 typeName = currentTemplate->templateParameters().at(n)->name();
         }
     }
@@ -604,19 +614,18 @@ TypeInfo BuilderPrivate::createTypeInfo(const CXType &type) const
 void BuilderPrivate::addTypeDef(const CXCursor &cursor, const CXType &cxType)
 {
     const QString target = getCursorSpelling(cursor);
-    TypeDefModelItem item(new _TypeDefModelItem(m_model, target));
-    setFileName(cursor, item.data());
+    auto item = std::make_shared<_TypeDefModelItem>(m_model, target);
+    setFileName(cursor, item.get());
     item->setType(createTypeInfo(cxType));
     item->setScope(m_scope);
     m_scopeStack.back()->addTypeDef(item);
-    m_cursorTypedefHash.insert(cursor, item);
 }
 
 ClassModelItem BuilderPrivate::currentTemplateClass() const
 {
     for (auto i = m_scopeStack.size() - 1; i >= 0; --i) {
-        auto klass = qSharedPointerDynamicCast<_ClassModelItem>(m_scopeStack.at(i));
-        if (!klass.isNull() && klass->isTemplate())
+        auto klass = std::dynamic_pointer_cast<_ClassModelItem>(m_scopeStack.at(i));
+        if (klass && klass->isTemplate())
             return klass;
     }
     return {};
@@ -626,7 +635,7 @@ void BuilderPrivate::startTemplateTypeAlias(const CXCursor &cursor)
 {
     const QString target = getCursorSpelling(cursor);
     m_currentTemplateTypeAlias.reset(new _TemplateTypeAliasModelItem(m_model, target));
-    setFileName(cursor, m_currentTemplateTypeAlias.data());
+    setFileName(cursor, m_currentTemplateTypeAlias.get());
     m_currentTemplateTypeAlias->setScope(m_scope);
 }
 
@@ -659,6 +668,9 @@ QString BuilderPrivate::cursorValueExpression(BaseVisitor *bv, const CXCursor &c
 }
 
 // Resolve a type (loop over aliases/typedefs), for example for base classes
+// Note: TypeAliasTemplateDecl ("using QVector<T>=QList<T>") is automatically
+// resolved by clang_getTypeDeclaration(), but it stops at
+// TypeAliasDecl / TypedefDecl.
 
 struct TypeDeclaration
 {
@@ -666,17 +678,21 @@ struct TypeDeclaration
     CXCursor declaration;
 };
 
-static TypeDeclaration resolveType(CXType type)
+static inline bool isTypeAliasDecl(const CXCursor &cursor)
+{
+    const auto kind = clang_getCursorKind(cursor);
+    return kind == CXCursor_TypeAliasDecl || kind == CXCursor_TypedefDecl;
+}
+
+static TypeDeclaration resolveBaseClassType(CXType type)
 {
     CXCursor decl = clang_getTypeDeclaration(type);
-    if (type.kind != CXType_Unexposed) {
-        while (true) {
-            auto kind = clang_getCursorKind(decl);
-            if (kind != CXCursor_TypeAliasDecl && kind != CXCursor_TypedefDecl)
-                break;
-            type = clang_getTypedefDeclUnderlyingType(decl);
-            decl = clang_getTypeDeclaration(type);
-        }
+    auto resolvedType = clang_getCursorType(decl);
+    if (resolvedType.kind != CXType_Invalid && resolvedType.kind != type.kind)
+        type = resolvedType;
+    while (isTypeAliasDecl(decl)) {
+        type = clang_getTypedefDeclUnderlyingType(decl);
+        decl = clang_getTypeDeclaration(type);
     }
     return {type, decl};
 }
@@ -685,21 +701,11 @@ static TypeDeclaration resolveType(CXType type)
 // where the cursor spelling has "struct baseClass".
 std::pair<QString, ClassModelItem> BuilderPrivate::getBaseClass(CXType type) const
 {
-    const auto decl = resolveType(type);
+    const auto decl = resolveBaseClassType(type);
     // Note: spelling has "struct baseClass", use type
-    QString baseClassName;
-    if (decl.type.kind == CXType_Unexposed) {
-        // The type is unexposed when the base class is a template type alias:
-        // "class QItemSelection : public QList<X>" where QList is aliased to QVector.
-        // Try to resolve via code model.
-        TypeInfo info = createTypeInfo(decl.type);
-        auto parentScope = m_scopeStack.at(m_scopeStack.size() - 2); // Current is class.
-        auto resolved = TypeInfo::resolveType(info, parentScope);
-        if (resolved != info)
-            baseClassName = resolved.toString();
-    }
-    if (baseClassName.isEmpty())
-        baseClassName = getTypeName(decl.type);
+    QString baseClassName = getTypeName(decl.type);
+    if (baseClassName.startsWith(u"std::")) // Simplify "std::" types
+        baseClassName = createTypeInfo(decl.type).toString();
 
     auto it = m_cursorClassHash.constFind(decl.declaration);
     // Not found: Set unqualified name. This happens in cases like
@@ -720,11 +726,11 @@ std::pair<QString, ClassModelItem> BuilderPrivate::getBaseClass(CXType type) con
     // "std::vector<T>").
     const QStringList &baseScope = it.value()->scope();
     if (!baseScope.isEmpty()) {
-        const int lastSep = baseClassName.lastIndexOf(colonColon());
+        const int lastSep = baseClassName.lastIndexOf(u"::"_s);
         if (lastSep >= 0)
-            baseClassName.remove(0, lastSep + colonColon().size());
-        baseClassName.prepend(colonColon());
-        baseClassName.prepend(baseScope.join(colonColon()));
+            baseClassName.remove(0, lastSep + u"::"_s.size());
+        baseClassName.prepend(u"::"_s);
+        baseClassName.prepend(baseScope.join(u"::"_s));
     }
     return {baseClassName, it.value()};
 }
@@ -738,37 +744,6 @@ void BuilderPrivate::addBaseClass(const CXCursor &cursor)
     m_currentClass->addBaseClass({baseClass.first, baseClass.second, access});
 }
 
-static inline CXCursor definitionFromTypeRef(const CXCursor &typeRefCursor)
-{
-    Q_ASSERT(typeRefCursor.kind == CXCursor_TypeRef);
-    return clang_getTypeDeclaration(clang_getCursorType(typeRefCursor));
-}
-
-// Qualify function arguments or fields that are typedef'ed from another scope:
-// enum ConversionFlag {};
-// typedef QFlags<ConversionFlag> ConversionFlags;
-// class QTextCodec {
-//      enum ConversionFlag {};
-//      typedef QFlags<ConversionFlag> ConversionFlags;
-//      struct ConverterState {
-//          explicit ConverterState(ConversionFlags);
-//                                  ^^ qualify to QTextCodec::ConversionFlags
-//          ConversionFlags m_flags;
-//                          ^^ ditto
-
-template <class Item> // ArgumentModelItem, VariableModelItem
-void BuilderPrivate::qualifyTypeDef(const CXCursor &typeRefCursor, const QSharedPointer<Item> &item) const
-{
-    TypeInfo type = item->type();
-    if (type.qualifiedName().size() == 1) { // item's type is unqualified.
-        const auto it = m_cursorTypedefHash.constFind(definitionFromTypeRef(typeRefCursor));
-        if (it != m_cursorTypedefHash.constEnd() && !it.value()->scope().isEmpty()) {
-            type.setQualifiedName(it.value()->scope() + type.qualifiedName());
-            item->setType(type);
-        }
-    }
-}
-
 void BuilderPrivate::setFileName(const CXCursor &cursor, _CodeModelItem *item)
 {
     const SourceRange range = getCursorRange(cursor);
@@ -802,8 +777,38 @@ static QString baseName(QString path)
     return path;
 }
 
+const char * BuilderPrivate::specialSystemHeaderReason(BuilderPrivate::SpecialSystemHeader sh)
+{
+    static const QHash<SpecialSystemHeader, const char *> mapping {
+        {SpecialSystemHeader::OpenGL, "OpenGL"},
+        {SpecialSystemHeader::Types, "types"},
+        {SpecialSystemHeader::WhiteListed, "white listed"},
+        {SpecialSystemHeader::WhiteListedPath,  "white listed path"}
+    };
+    return mapping.value(sh, "");
+}
+
 bool BuilderPrivate::visitHeader(const QString &fileName) const
 {
+    auto it = m_systemHeaders.find(fileName);
+    if (it == m_systemHeaders.end()) {
+        it = m_systemHeaders.insert(fileName, specialSystemHeader(fileName));
+        if (ReportHandler::isDebug(ReportHandler::MediumDebug)) {
+            const QString &name = QDir::toNativeSeparators(fileName);
+            if (it.value() == SpecialSystemHeader::None) {
+                qCInfo(lcShiboken, "Skipping system header %s", qPrintable(name));
+            } else {
+                qCInfo(lcShiboken, "Parsing system header %s (%s)",
+                       qPrintable(name), specialSystemHeaderReason(it.value()));
+            }
+        }
+    }
+    return it.value() != SpecialSystemHeader::None;
+}
+
+BuilderPrivate::SpecialSystemHeader
+    BuilderPrivate::specialSystemHeader(const QString &fileName) const
+{
     // Resolve OpenGL typedefs although the header is considered a system header.
     const QString baseName = clang::baseName(fileName);
     if (baseName == u"gl.h"
@@ -812,8 +817,8 @@ bool BuilderPrivate::visitHeader(const QString &fileName) const
         || baseName == u"gl31.h"
         || baseName == u"gl32.h"
         || baseName == u"stdint.h" // Windows: int32_t, uint32_t
-        || baseName == u"stddef.h") { // size_t
-        return true;
+        || baseName == u"stddef.h") { // size_t`
+        return SpecialSystemHeader::OpenGL;
     }
 
     switch (clang::platform()) {
@@ -822,7 +827,7 @@ bool BuilderPrivate::visitHeader(const QString &fileName) const
             || baseName == u"types.h"
             || baseName == u"stdint-intn.h" // int32_t
             || baseName == u"stdint-uintn.h") { // uint32_t
-            return true;
+            return SpecialSystemHeader::Types;
         }
         break;
     case Platform::macOS:
@@ -832,22 +837,28 @@ bool BuilderPrivate::visitHeader(const QString &fileName) const
         if (baseName == u"gltypes.h"
             || fileName.contains(u"/usr/include/_types")
             || fileName.contains(u"/usr/include/sys/_types")) {
-            return true;
+            return SpecialSystemHeader::Types;
         }
         break;
     default:
         break;
     }
 
-    for (const auto &systemInclude : m_systemIncludes) {
-        if (systemInclude == baseName)
-            return true;
-    }
-    for (const auto &systemIncludePath : m_systemIncludePaths) {
-        if (fileName.startsWith(systemIncludePath))
-            return true;
+    // When building against system Qt (as it happens with yocto / Boot2Qt), the Qt headers are
+    // considered system headers by clang_Location_isInSystemHeader, and shiboken will not
+    // process them. We need to explicitly process them by checking against the list of
+    // include paths that were passed to shiboken's --force-process-system-include-paths option
+    // or specified via the <system-include> xml tag.
+    if (m_forceProcessSystemIncludes.contains(baseName))
+        return SpecialSystemHeader::WhiteListed;
+
+    if (std::any_of(m_forceProcessSystemIncludePaths.cbegin(),
+                    m_forceProcessSystemIncludePaths.cend(),
+                    [fileName](const QString &p) { return fileName.startsWith(p); })) {
+        return SpecialSystemHeader::WhiteListedPath;
     }
-    return false;
+
+    return SpecialSystemHeader::None;
 }
 
 bool Builder::visitLocation(const QString &fileName, LocationType locationType) const
@@ -855,13 +866,14 @@ bool Builder::visitLocation(const QString &fileName, LocationType locationType)
     return locationType != LocationType::System || d->visitHeader(fileName);
 }
 
-void Builder::setSystemIncludes(const QStringList &systemIncludes)
+void Builder::setForceProcessSystemIncludes(const QStringList &systemIncludes)
 {
     for (const auto &i : systemIncludes) {
-        if (i.endsWith(u'/'))
-            d->m_systemIncludePaths.append(i);
+        QFileInfo fi(i);
+        if (fi.exists() && fi.isDir())
+            d->m_forceProcessSystemIncludePaths.append(i);
         else
-            d->m_systemIncludes.append(i);
+            d->m_forceProcessSystemIncludes.append(i);
     }
 }
 
@@ -870,7 +882,7 @@ FileModelItem Builder::dom() const
     Q_ASSERT(!d->m_scopeStack.isEmpty());
     auto rootScope = d->m_scopeStack.constFirst();
     rootScope->purgeClassDeclarations();
-    return qSharedPointerDynamicCast<_FileModelItem>(rootScope);
+    return std::dynamic_pointer_cast<_FileModelItem>(rootScope);
 }
 
 static QString msgOutOfOrder(const CXCursor &cursor, const char *expectedScope)
@@ -904,6 +916,8 @@ static NamespaceType namespaceType(const CXCursor &cursor)
 static QString enumType(const CXCursor &cursor)
 {
     QString name = getCursorSpelling(cursor); // "enum Foo { v1, v2 };"
+    if (name.contains(u"unnamed enum")) // Clang 16.0
+        return {};
     if (name.isEmpty()) {
         // PYSIDE-1228: For "typedef enum { v1, v2 } Foo;", type will return
         // "Foo" as expected. Care must be taken to exclude real anonymous enums.
@@ -933,7 +947,7 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
     }
         break;
     case CXCursor_CXXBaseSpecifier:
-        if (d->m_currentClass.isNull()) {
+        if (!d->m_currentClass) {
             const Diagnostic d(msgOutOfOrder(cursor, "class"), cursor, CXDiagnostic_Error);
             qWarning() << d;
             appendDiagnostic(d);
@@ -955,15 +969,15 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
             || !d->addClass(cursor, CodeModel::Class)) {
             return Skip;
         }
-        d->m_currentClass->setName(d->m_currentClass->name() + templateBrackets());
-        d->m_scope.back() += templateBrackets();
+        d->m_currentClass->setName(d->m_currentClass->name() + "<>"_L1);
+        d->m_scope.back() += "<>"_L1;
         break;
     case CXCursor_EnumDecl: {
         QString name = enumType(cursor);
         EnumKind kind = CEnum;
         if (name.isEmpty()) {
             kind = AnonymousEnum;
-            name = QStringLiteral("enum_") + QString::number(++d->m_anonymousEnumCount);
+            name = "enum_"_L1 + QString::number(++d->m_anonymousEnumCount);
 #if !CLANG_NO_ENUMDECL_ISSCOPED
         } else if (clang_EnumDecl_isScoped(cursor) != 0) {
 #else
@@ -972,19 +986,21 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
             kind = EnumClass;
         }
         d->m_currentEnum.reset(new _EnumModelItem(d->m_model, name));
-        d->setFileName(cursor, d->m_currentEnum.data());
+        d->setFileName(cursor, d->m_currentEnum.get());
         d->m_currentEnum->setScope(d->m_scope);
         d->m_currentEnum->setEnumKind(kind);
         if (clang_getCursorAvailability(cursor) == CXAvailability_Deprecated)
             d->m_currentEnum->setDeprecated(true);
-        d->m_currentEnum->setSigned(isSigned(clang_getEnumDeclIntegerType(cursor).kind));
-        if (!qSharedPointerDynamicCast<_ClassModelItem>(d->m_scopeStack.back()).isNull())
+        const auto enumType = fullyResolveType(clang_getEnumDeclIntegerType(cursor));
+        d->m_currentEnum->setSigned(isSigned(enumType.kind));
+        d->m_currentEnum->setUnderlyingType(getTypeName(enumType));
+        if (std::dynamic_pointer_cast<_ClassModelItem>(d->m_scopeStack.back()))
             d->m_currentEnum->setAccessPolicy(accessPolicy(clang_getCXXAccessSpecifier(cursor)));
     }
         break;
     case CXCursor_EnumConstantDecl: {
         const QString name = getCursorSpelling(cursor);
-        if (d->m_currentEnum.isNull()) {
+        if (!d->m_currentEnum) {
             const Diagnostic d(msgOutOfOrder(cursor, "enum"), cursor, CXDiagnostic_Error);
             qWarning() << d;
             appendDiagnostic(d);
@@ -995,7 +1011,7 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
             enumValue.setValue(clang_getEnumConstantDeclValue(cursor));
         else
             enumValue.setUnsignedValue(clang_getEnumConstantDeclUnsignedValue(cursor));
-        EnumeratorModelItem enumConstant(new _EnumeratorModelItem(d->m_model, name));
+        auto enumConstant = std::make_shared<_EnumeratorModelItem>(d->m_model, name);
         enumConstant->setStringValue(d->cursorValueExpression(this, cursor));
         enumConstant->setValue(enumValue);
         if (clang_getCursorAvailability(cursor) == CXAvailability_Deprecated)
@@ -1043,6 +1059,7 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
         }
     }
         d->m_currentFunction = d->createFunction(cursor, CodeModel::Normal, true);
+        d->setFileName(cursor, d->m_currentFunction.get());
         d->m_scopeStack.back()->addFunction(d->m_currentFunction);
         break;
     case CXCursor_FunctionDecl:
@@ -1066,8 +1083,8 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
         if (type == NamespaceType::Anonymous)
             return Skip;
         const QString name = getCursorSpelling(cursor);
-        const NamespaceModelItem parentNamespaceItem = qSharedPointerDynamicCast<_NamespaceModelItem>(d->m_scopeStack.back());
-        if (parentNamespaceItem.isNull()) {
+        const auto parentNamespaceItem = std::dynamic_pointer_cast<_NamespaceModelItem>(d->m_scopeStack.back());
+        if (!parentNamespaceItem) {
             const QString message = msgOutOfOrder(cursor, "namespace")
                 + u" (current scope: "_s + d->m_scopeStack.back()->name() + u')';
             const Diagnostic d(message, cursor, CXDiagnostic_Error);
@@ -1079,7 +1096,7 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
         // in subsequent modules.
         NamespaceModelItem namespaceItem = parentNamespaceItem->findNamespace(name);
         namespaceItem.reset(new _NamespaceModelItem(d->m_model, name));
-        d->setFileName(cursor, namespaceItem.data());
+        d->setFileName(cursor, namespaceItem.get());
         namespaceItem->setScope(d->m_scope);
         namespaceItem->setType(type);
         parentNamespaceItem->addNamespace(namespaceItem);
@@ -1089,10 +1106,12 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
     case CXCursor_ParmDecl:
         // Skip in case of nested CXCursor_ParmDecls in case one parameter is a function pointer
         // and function pointer typedefs.
-        if (d->m_currentArgument.isNull() && !d->m_currentFunction.isNull()) {
+        if (!d->m_currentArgument && d->m_currentFunction) {
             const QString name = getCursorSpelling(cursor);
             d->m_currentArgument.reset(new _ArgumentModelItem(d->m_model, name));
-            d->m_currentArgument->setType(d->createTypeInfo(cursor));
+            const auto type = clang_getCursorType(cursor);
+            d->m_currentArgument->setScopeResolution(hasScopeResolution(type));
+            d->m_currentArgument->setType(d->createTypeInfo(type));
             d->m_currentFunction->addArgument(d->m_currentArgument);
             QString defaultValueExpression = d->cursorValueExpression(this, cursor);
             if (!defaultValueExpression.isEmpty()) {
@@ -1108,16 +1127,16 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
         const TemplateParameterModelItem tItem = cursor.kind == CXCursor_TemplateTemplateParameter
             ? d->createTemplateParameter(cursor) : d->createNonTypeTemplateParameter(cursor);
         // Apply to function/member template?
-        if (!d->m_currentFunction.isNull()) {
+        if (d->m_currentFunction) {
             d->m_currentFunction->setTemplateParameters(d->m_currentFunction->templateParameters() << tItem);
-        } else if (!d->m_currentTemplateTypeAlias.isNull()) {
+        } else if (d->m_currentTemplateTypeAlias) {
             d->m_currentTemplateTypeAlias->addTemplateParameter(tItem);
-        } else if (!d->m_currentClass.isNull()) { // Apply to class
+        } else if (d->m_currentClass) { // Apply to class
             const QString &tplParmName = tItem->name();
             if (Q_UNLIKELY(!insertTemplateParameterIntoClassName(tplParmName, d->m_currentClass)
                            || !insertTemplateParameterIntoClassName(tplParmName, &d->m_scope.back()))) {
-                const QString message = QStringLiteral("Error inserting template parameter \"") + tplParmName
-                        + QStringLiteral("\" into ") + d->m_currentClass->name();
+                const QString message = "Error inserting template parameter \""_L1 + tplParmName
+                        + "\" into "_L1 + d->m_currentClass->name();
                 const Diagnostic d(message, cursor, CXDiagnostic_Error);
                 qWarning() << d;
                 appendDiagnostic(d);
@@ -1131,7 +1150,7 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
         d->startTemplateTypeAlias(cursor);
         break;
     case CXCursor_TypeAliasDecl: // May contain nested CXCursor_TemplateTypeParameter
-        if (d->m_currentTemplateTypeAlias.isNull()) {
+        if (!d->m_currentTemplateTypeAlias) {
             const CXType type = clang_getCanonicalType(clang_getCursorType(cursor));
             if (type.kind > CXType_Unexposed)
                 d->addTypeDef(cursor, type);
@@ -1159,31 +1178,23 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
             d->m_usingTypeRef = getCursorSpelling(cursor);
         break;
     case CXCursor_TypeRef:
-        if (!d->m_currentFunction.isNull()) {
-            if (d->m_currentArgument.isNull())
-                d->qualifyTypeDef(cursor, d->m_currentFunction); // return type
-            else
-                d->qualifyTypeDef(cursor, d->m_currentArgument);
-        } else if (!d->m_currentField.isNull()) {
-            d->qualifyTypeDef(cursor, d->m_currentField);
-        } else if (d->m_withinUsingDeclaration && d->m_usingTypeRef.isEmpty()) {
+        if (d->m_withinUsingDeclaration && d->m_usingTypeRef.isEmpty())
             d->m_usingTypeRef = d->getBaseClass(clang_getCursorType(cursor)).first;
-        }
         break;
     case CXCursor_CXXFinalAttr:
-         if (!d->m_currentFunction.isNull())
-             d->m_currentFunction->setFinal(true);
-         else if (!d->m_currentClass.isNull())
+         if (d->m_currentFunction)
+            d->m_currentFunction->setAttribute(FunctionAttribute::Final);
+         else if (d->m_currentClass)
              d->m_currentClass->setFinal(true);
         break;
     case CXCursor_CXXOverrideAttr:
-        if (!d->m_currentFunction.isNull())
-            d->m_currentFunction->setOverride(true);
+        if (d->m_currentFunction)
+            d->m_currentFunction->setAttribute(FunctionAttribute::Override);
         break;
     case CXCursor_StaticAssert:
         // Check for Q_PROPERTY() (see PySide6/global.h.in for an explanation
         // how it is defined, and qdoc).
-        if (clang_isDeclaration(cursor.kind) && !d->m_currentClass.isNull()) {
+        if (clang_isDeclaration(cursor.kind) && d->m_currentClass) {
             auto snippet = getCodeSnippet(cursor);
             const auto length = snippet.size();
             if (length > 12 && *snippet.rbegin() == ')'
@@ -1195,7 +1206,7 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
         break;
     // UsingDeclaration: consists of a TypeRef (base) and OverloadedDeclRef (member name)
     case CXCursor_UsingDeclaration:
-        if (!d->m_currentClass.isNull())
+        if (d->m_currentClass)
             d->m_withinUsingDeclaration = true;
         break;
     case CXCursor_OverloadedDeclRef:
@@ -1223,51 +1234,51 @@ bool Builder::endToken(const CXCursor &cursor)
     case CXCursor_ClassTemplatePartialSpecialization:
         d->popScope();
         // Continue in outer class after leaving inner class?
-        if (ClassModelItem lastClass = qSharedPointerDynamicCast<_ClassModelItem>(d->m_scopeStack.back()))
+        if (auto lastClass = std::dynamic_pointer_cast<_ClassModelItem>(d->m_scopeStack.back()))
             d->m_currentClass = lastClass;
         else
-            d->m_currentClass.clear();
+            d->m_currentClass.reset();
         d->m_currentFunctionType = CodeModel::Normal;
         break;
     case CXCursor_EnumDecl:
-        if (!d->m_currentEnum.isNull())
+        if (d->m_currentEnum)
             d->m_scopeStack.back()->addEnum(d->m_currentEnum);
-        d->m_currentEnum.clear();
+        d->m_currentEnum.reset();
         break;
     case CXCursor_FriendDecl:
         d->m_withinFriendDecl = false;
         break;
     case CXCursor_VarDecl:
     case CXCursor_FieldDecl:
-        d->m_currentField.clear();
+        d->m_currentField.reset();
         break;
     case CXCursor_Constructor:
         d->qualifyConstructor(cursor);
-        if (!d->m_currentFunction.isNull()) {
+        if (d->m_currentFunction) {
             d->m_currentFunction->_determineType();
-            d->m_currentFunction.clear();
+            d->m_currentFunction.reset();
         }
         break;
     case CXCursor_Destructor:
     case CXCursor_CXXMethod:
     case CXCursor_FunctionDecl:
     case CXCursor_FunctionTemplate:
-        if (!d->m_currentFunction.isNull()) {
+        if (d->m_currentFunction) {
             d->m_currentFunction->_determineType();
-            d->m_currentFunction.clear();
+            d->m_currentFunction.reset();
         }
         break;
     case CXCursor_ConversionFunction:
-        if (!d->m_currentFunction.isNull()) {
+        if (d->m_currentFunction) {
             d->m_currentFunction->setFunctionType(CodeModel::ConversionOperator);
-            d->m_currentFunction.clear();
+            d->m_currentFunction.reset();
         }
         break;
     case CXCursor_Namespace:
         d->popScope();
         break;
     case CXCursor_ParmDecl:
-        d->m_currentArgument.clear();
+        d->m_currentArgument.reset();
         break;
     case CXCursor_TypeAliasTemplateDecl:
         d->m_currentTemplateTypeAlias.reset();
diff --git a/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.h b/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.h
index 56b6347d5..b2ec6d304 100644
--- a/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.h
+++ b/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.h
@@ -14,12 +14,12 @@ class BuilderPrivate;
 
 class Builder : public BaseVisitor {
 public:
-    Q_DISABLE_COPY(Builder)
+    Q_DISABLE_COPY_MOVE(Builder)
 
     Builder();
     ~Builder();
 
-    void setSystemIncludes(const QStringList &systemIncludes);
+    void setForceProcessSystemIncludes(const QStringList &systemIncludes);
 
     bool visitLocation(const QString &fileName, LocationType locationType) const override;
 
diff --git a/sources/shiboken6/ApiExtractor/clangparser/clangdebugutils.cpp b/sources/shiboken6/ApiExtractor/clangparser/clangdebugutils.cpp
index 93618cf0f..3c002da9c 100644
--- a/sources/shiboken6/ApiExtractor/clangparser/clangdebugutils.cpp
+++ b/sources/shiboken6/ApiExtractor/clangparser/clangdebugutils.cpp
@@ -7,8 +7,6 @@
 #include <QtCore/QDebug>
 #include <QtCore/QString>
 
-#include <string.h>
-
 #ifndef QT_NO_DEBUG_STREAM
 
 #ifdef Q_OS_WIN
@@ -19,7 +17,7 @@ const char pathSep = '/';
 
 static const char *baseName(const char *fileName)
 {
-    const char *b = strrchr(fileName, pathSep);
+    const char *b = std::strrchr(fileName, pathSep);
     return b ? b + 1 : fileName;
 }
 
@@ -49,59 +47,99 @@ QDebug operator<<(QDebug s, CX_CXXAccessSpecifier ac)
     return s;
 }
 
-QDebug operator<<(QDebug s, const CXType &t)
+struct formatCXTypeName
+{
+    explicit formatCXTypeName(const CXType &type) : m_type(type) {}
+
+    const CXType &m_type;
+};
+
+QDebug operator<<(QDebug debug, const formatCXTypeName &ft)
 {
-    CXString typeSpelling = clang_getTypeSpelling(t);
-    s << typeSpelling;
+    CXString typeSpelling = clang_getTypeSpelling(ft.m_type);
+    debug << typeSpelling;
     clang_disposeString(typeSpelling);
-    return s;
+    return debug;
 }
 
-QDebug operator<<(QDebug s, const CXCursor &cursor)
+QDebug operator<<(QDebug debug, const CXType &type)
 {
-    QDebugStateSaver saver(s);
-    s.nospace();
-    s.noquote();
+    QDebugStateSaver saver(debug);
+    debug.nospace();
+    debug.noquote();
+    debug << "CXType(";
+    if (type.kind == CXType_Invalid) {
+        debug << "invalid)";
+        return debug;
+    }
+
+    debug << type.kind;
+    switch (type.kind) {
+    case CXType_Unexposed:
+        debug << " [unexposed]";
+        break;
+    case CXType_Elaborated:
+        debug << " [elaborated]";
+        break;
+    default:
+        break;
+    }
+    debug << ", " << formatCXTypeName(type) << ')';
+    return debug;
+}
+
+QDebug operator<<(QDebug debug, const CXCursor &cursor)
+{
+    QDebugStateSaver saver(debug);
+    debug.nospace();
+    debug.noquote();
     const CXCursorKind kind = clang_getCursorKind(cursor);
-    s << kind;
-    if (kind >= CXCursor_FirstInvalid && kind <= CXCursor_LastInvalid)
-        return s;
+    debug << "CXCursor(";
+    if (kind >= CXCursor_FirstInvalid && kind <= CXCursor_LastInvalid) {
+        debug << "invalid)";
+        return debug;
+    }
+
+    const QString cursorSpelling = clang::getCursorSpelling(cursor);
+    debug << '"' << cursorSpelling << '"';
+    CXString cursorDisplay = clang_getCursorDisplayName(cursor);
+    if (const char *dpy = clang_getCString(cursorDisplay)) {
+        const QString display = QString::fromUtf8(dpy);
+        if (display != cursorSpelling)
+            debug << ", display=\"" << dpy << '"';
+    }
+    clang_disposeString(cursorDisplay);
+
+    debug << ", kind=" << kind;
+
     const CXType type = clang_getCursorType(cursor);
     switch (kind) {
         case CXCursor_CXXAccessSpecifier:
-        s << ' ' << clang_getCXXAccessSpecifier(cursor);
+        debug << ", " << clang_getCXXAccessSpecifier(cursor);
         break;
     case CXCursor_CXXBaseSpecifier:
-         s << ", inherits=\"" << clang::getCursorSpelling(clang_getTypeDeclaration(type)) << '"';
+         debug << ", inherits=\"" << clang::getCursorSpelling(clang_getTypeDeclaration(type)) << '"';
          break;
     case CXCursor_CXXMethod:
     case CXCursor_FunctionDecl:
     case CXCursor_ConversionFunction:
-        s << ", result type=\"" << clang_getCursorResultType(cursor) << '"';
+         debug << ", result type=\""
+            << formatCXTypeName(clang_getCursorResultType(cursor)) << '"';
         break;
     case CXCursor_TypedefDecl:
-        s << ", underlyingType=\"" << clang_getTypedefDeclUnderlyingType(cursor) << '"';
+        debug << ", underlyingType=\""
+            << formatCXTypeName(clang_getTypedefDeclUnderlyingType(cursor)) << '"';
         break;
     default:
         break;
     }
 
-    if (type.kind != CXType_Invalid)
-        s  << ", type=\"" << type << '"';
+    debug << ", type=\"" << formatCXTypeName(type) << '"';
     if (clang_Cursor_hasAttrs(cursor))
-        s  << ", [attrs]";
+        debug << ", [attrs]";
 
-    const QString cursorSpelling = clang::getCursorSpelling(cursor);
-    if (!cursorSpelling.isEmpty())
-        s << ", spelling=\"" << cursorSpelling << '"';
-    CXString cursorDisplay = clang_getCursorDisplayName(cursor);
-    if (const char *dpy = clang_getCString(cursorDisplay)) {
-        const QString display = QString::fromUtf8(dpy);
-        if (display != cursorSpelling)
-            s << ", display=\"" << dpy << '"';
-    }
-    clang_disposeString(cursorDisplay);
-    return s;
+    debug << ')';
+    return debug;
 }
 
 QDebug operator<<(QDebug s, const CXSourceLocation &location)
diff --git a/sources/shiboken6/ApiExtractor/clangparser/clangdebugutils.h b/sources/shiboken6/ApiExtractor/clangparser/clangdebugutils.h
index 3a1b91e1a..7aac8a575 100644
--- a/sources/shiboken6/ApiExtractor/clangparser/clangdebugutils.h
+++ b/sources/shiboken6/ApiExtractor/clangparser/clangdebugutils.h
@@ -4,7 +4,7 @@
 #ifndef CLANGDEBUGUTILS_H
 #define CLANGDEBUGUTILS_H
 
-#include <QtCore/QtGlobal>
+#include <QtCore/qtclasshelpermacros.h>
 
 #include <clang-c/Index.h>
 
diff --git a/sources/shiboken6/ApiExtractor/clangparser/clangparser.cpp b/sources/shiboken6/ApiExtractor/clangparser/clangparser.cpp
index 9762b352f..6c0cf3ae2 100644
--- a/sources/shiboken6/ApiExtractor/clangparser/clangparser.cpp
+++ b/sources/shiboken6/ApiExtractor/clangparser/clangparser.cpp
@@ -13,6 +13,8 @@
 #include <QtCore/QScopedArrayPointer>
 #include <QtCore/QString>
 
+using namespace Qt::StringLiterals;
+
 namespace clang {
 
 QString SourceFileCache::getFileName(CXFile file)
@@ -39,7 +41,7 @@ std::string_view SourceFileCache::getCodeSnippet(const CXCursor &cursor,
 
     if (range.first.file != range.second.file) {
         if (errorMessage)
-            *errorMessage = QStringLiteral("Range spans several files");
+            *errorMessage = "Range spans several files"_L1;
         return std::string_view(empty, 0);
     }
 
@@ -48,7 +50,7 @@ std::string_view SourceFileCache::getCodeSnippet(const CXCursor &cursor,
         const QString fileName = getFileName(range.first.file);
         if (fileName.isEmpty()) {
             if (errorMessage)
-                 *errorMessage = QStringLiteral("Range has no file");
+                 *errorMessage = "Range has no file"_L1;
             return std::string_view(empty, 0);
         }
         QFile file(fileName);
@@ -233,6 +235,7 @@ static QByteArray msgCreateTranslationUnit(const QByteArrayList &clangArgs, unsi
 static CXTranslationUnit createTranslationUnit(CXIndex index,
                                                const QByteArrayList &args,
                                                bool addCompilerSupportArguments,
+                                               LanguageLevel level,
                                                unsigned flags = 0)
 {
     // courtesy qdoc
@@ -253,7 +256,7 @@ static CXTranslationUnit createTranslationUnit(CXIndex index,
 
     QByteArrayList clangArgs;
     if (addCompilerSupportArguments) {
-        clangArgs += emulatedCompilerOptions();
+        clangArgs += emulatedCompilerOptions(level);
         clangArgs += defaultArgs;
     }
     clangArgs += detectVulkan();
@@ -278,7 +281,7 @@ static CXTranslationUnit createTranslationUnit(CXIndex index,
  */
 
 bool parse(const QByteArrayList  &clangArgs, bool addCompilerSupportArguments,
-           unsigned clangFlags, BaseVisitor &bv)
+           LanguageLevel level, unsigned clangFlags, BaseVisitor &bv)
 {
     CXIndex index = clang_createIndex(0 /* excludeDeclarationsFromPCH */,
                                       1 /* displayDiagnostics */);
@@ -289,7 +292,7 @@ bool parse(const QByteArrayList  &clangArgs, bool addCompilerSupportArguments,
 
     CXTranslationUnit translationUnit =
         createTranslationUnit(index, clangArgs, addCompilerSupportArguments,
-                              clangFlags);
+                              level, clangFlags);
     if (!translationUnit)
         return false;
 
diff --git a/sources/shiboken6/ApiExtractor/clangparser/clangparser.h b/sources/shiboken6/ApiExtractor/clangparser/clangparser.h
index 3abbece24..22e0a50cd 100644
--- a/sources/shiboken6/ApiExtractor/clangparser/clangparser.h
+++ b/sources/shiboken6/ApiExtractor/clangparser/clangparser.h
@@ -8,11 +8,13 @@
 
 #include <QtCore/QByteArrayList>
 #include <QtCore/QHash>
-#include <QtCore/QPair>
 #include <QtCore/QString>
 #include <QtCore/QList>
 
 #include <string_view>
+#include <utility>
+
+enum class LanguageLevel;
 
 namespace clang {
 
@@ -40,7 +42,7 @@ enum class LocationType
 };
 
 class BaseVisitor {
-    Q_DISABLE_COPY(BaseVisitor)
+    Q_DISABLE_COPY_MOVE(BaseVisitor)
 public:
     using Diagnostics = QList<Diagnostic>;
 
@@ -79,7 +81,7 @@ private:
 
 bool parse(const QByteArrayList  &clangArgs,
            bool addCompilerSupportArguments,
-           unsigned clangFlags, BaseVisitor &ctx);
+           LanguageLevel level, unsigned clangFlags, BaseVisitor &ctx);
 
 } // namespace clang
 
diff --git a/sources/shiboken6/ApiExtractor/clangparser/clangutils.cpp b/sources/shiboken6/ApiExtractor/clangparser/clangutils.cpp
index 6955e4ec2..1651e09ec 100644
--- a/sources/shiboken6/ApiExtractor/clangparser/clangutils.cpp
+++ b/sources/shiboken6/ApiExtractor/clangparser/clangutils.cpp
@@ -8,38 +8,33 @@
 #include <QtCore/QHashFunctions>
 #include <QtCore/QProcess>
 
-bool operator==(const CXCursor &c1, const CXCursor &c2)
+#include <string_view>
+
+bool operator==(const CXCursor &c1, const CXCursor &c2) noexcept
 {
     return c1.kind == c2.kind
         && c1.xdata == c2.xdata
         && std::equal(c1.data, c1.data + sizeof(c1.data) / sizeof(c1.data[0]), c2.data);
 }
 
-size_t qHash(const CXCursor &c, size_t seed)
+size_t qHash(const CXCursor &c, size_t seed) noexcept
 {
-    return qHash(c.kind) ^ qHash(c.xdata) ^ qHash(c.data[0])
-        ^ qHash(c.data[1])  ^ qHash(c.data[2]) ^ seed;
+    return qHashMulti(seed, c.kind, c.xdata, c.data[0], c.data[1], c.data[2]);
 }
 
-bool operator==(const CXType &t1, const CXType &t2)
+bool operator==(const CXType &t1, const CXType &t2) noexcept
 {
     return t1.kind == t2.kind && t1.data[0] == t2.data[0]
         && t1.data[1] == t2.data[1];
 }
 
-size_t qHash(const CXType &ct, size_t seed)
+size_t qHash(const CXType &ct, size_t seed) noexcept
 {
-    return size_t(ct.kind) ^ size_t(0xFFFFFFFF & quintptr(ct.data[0]))
-        ^ size_t(0xFFFFFFFF & quintptr(ct.data[1])) ^ seed;
+    return qHashMulti(seed, ct.kind, ct.data[0], ct.data[1]);
 }
 
 namespace clang {
 
-bool SourceLocation::equals(const SourceLocation &rhs) const
-{
-    return file == rhs.file && offset == rhs.offset;
-}
-
 SourceLocation getExpansionLocation(const CXSourceLocation &location)
 {
     SourceLocation result;
@@ -77,8 +72,8 @@ CXString getFileNameFromLocation(const CXSourceLocation &location)
 SourceRange getCursorRange(const CXCursor &cursor)
 {
     const CXSourceRange extent = clang_getCursorExtent(cursor);
-    return qMakePair(getExpansionLocation(clang_getRangeStart(extent)),
-                     getExpansionLocation(clang_getRangeEnd(extent)));
+    return std::make_pair(getExpansionLocation(clang_getRangeStart(extent)),
+                          getExpansionLocation(clang_getRangeEnd(extent)));
 }
 
 QString getCursorKindName(CXCursorKind cursorKind)
@@ -105,6 +100,43 @@ QString getCursorDisplayName(const CXCursor &cursor)
     return result;
 }
 
+static inline bool isBuiltinType(CXTypeKind kind)
+{
+    return kind >= CXType_FirstBuiltin && kind <= CXType_LastBuiltin;
+}
+
+// Resolve elaborated types occurring with clang 16
+static CXType resolveElaboratedType(const CXType &type)
+{
+    if (!isBuiltinType(type.kind)) {
+        CXCursor decl = clang_getTypeDeclaration(type);
+        auto resolvedType = clang_getCursorType(decl);
+        if (resolvedType.kind != CXType_Invalid && resolvedType.kind != type.kind)
+            return resolvedType;
+    }
+    return type;
+}
+
+// Resolve typedefs
+static CXType resolveTypedef(const CXType &type)
+{
+    auto result = type;
+    while (result.kind == CXType_Typedef) {
+        auto decl = clang_getTypeDeclaration(result);
+        auto resolved = clang_getTypedefDeclUnderlyingType(decl);
+        if (resolved.kind == CXType_Invalid)
+            break;
+        result = resolved;
+    }
+    return result;
+}
+
+// Fully resolve a type from elaborated & typedefs
+CXType fullyResolveType(const CXType &type)
+{
+    return resolveTypedef(resolveElaboratedType(type));
+}
+
 QString getTypeName(const CXType &type)
 {
     CXString typeSpelling = clang_getTypeSpelling(type);
@@ -113,6 +145,23 @@ QString getTypeName(const CXType &type)
     return result;
 }
 
+// Quick check for "::Type"
+bool hasScopeResolution(const CXType &type)
+{
+    CXString typeSpelling = clang_getTypeSpelling(type);
+    std::string_view spelling = clang_getCString(typeSpelling);
+    const bool result = spelling.compare(0, 2, "::") == 0
+        || spelling.find(" ::") != std::string::npos;
+    clang_disposeString(typeSpelling);
+    return result;
+}
+
+// Resolve elaborated types occurring with clang 16
+QString getResolvedTypeName(const CXType &type)
+{
+    return getTypeName(resolveElaboratedType(type));
+}
+
 Diagnostic::Diagnostic(const QString &m, const CXCursor &c, CXDiagnosticSeverity s)
     : message(m), source(Other), severity(s)
 {
@@ -166,14 +215,14 @@ QList<Diagnostic> getDiagnostics(CXTranslationUnit tu)
     return result;
 }
 
-QPair<qsizetype, qsizetype>
+std::pair<qsizetype, qsizetype>
     parseTemplateArgumentList(const QString &l,
                               const TemplateArgumentHandler &handler,
                               qsizetype from)
 {
     const auto ltPos = l.indexOf(u'<', from);
     if (ltPos == - 1)
-        return qMakePair(-1, -1);
+        return std::make_pair(-1, -1);
     auto startPos = ltPos + 1;
     int level = 1;
     for (qsizetype p = startPos, end = l.size(); p < end; ) {
@@ -185,7 +234,7 @@ QPair<qsizetype, qsizetype>
             ++p;
             if (c == '>') {
                 if (--level == 0)
-                    return qMakePair(ltPos, p);
+                    return std::make_pair(ltPos, p);
                 // Skip over next ',': "a<b<c,d>,e>"
                 for (; p < end && (l.at(p).isSpace() || l.at(p) == u','); ++p) {}
             }
@@ -201,7 +250,7 @@ QPair<qsizetype, qsizetype>
             break;
         }
     }
-    return qMakePair(-1, -1);
+    return std::make_pair(-1, -1);
 }
 
 CXDiagnosticSeverity maxSeverity(const QList<Diagnostic> &ds)
diff --git a/sources/shiboken6/ApiExtractor/clangparser/clangutils.h b/sources/shiboken6/ApiExtractor/clangparser/clangutils.h
index 9ad0cbc57..fbbf95f1b 100644
--- a/sources/shiboken6/ApiExtractor/clangparser/clangutils.h
+++ b/sources/shiboken6/ApiExtractor/clangparser/clangutils.h
@@ -5,20 +5,21 @@
 #define CLANGUTILS_H
 
 #include <clang-c/Index.h>
-#include <QtCore/QPair>
 #include <QtCore/QString>
 #include <QtCore/QStringList>
+#include <QtCore/QtCompare>
 #include <QtCore/QList>
 
 #include <functional>
+#include <utility>
 
 QT_FORWARD_DECLARE_CLASS(QDebug)
 
-bool operator==(const CXCursor &c1, const CXCursor &c2);
-size_t qHash(const CXCursor &c, size_t seed = 0);
+bool operator==(const CXCursor &c1, const CXCursor &c2) noexcept;
+size_t qHash(const CXCursor &c, size_t seed = 0) noexcept;
 
-bool operator==(const CXType &t1, const CXType &t2);
-size_t qHash(const CXType &ct, size_t seed);
+bool operator==(const CXType &t1, const CXType &t2) noexcept;
+size_t qHash(const CXType &ct, size_t seed = 0) noexcept;
 
 namespace clang {
 
@@ -26,6 +27,9 @@ QString getCursorKindName(CXCursorKind cursorKind);
 QString getCursorSpelling(const CXCursor &cursor);
 QString getCursorDisplayName(const CXCursor &cursor);
 QString getTypeName(const CXType &type);
+bool hasScopeResolution(const CXType &type);
+CXType fullyResolveType(const CXType &type);
+QString getResolvedTypeName(const CXType &type);
 inline QString getCursorTypeName(const CXCursor &cursor)
     { return getTypeName(clang_getCursorType(cursor)); }
 inline QString getCursorResultTypeName(const CXCursor &cursor)
@@ -46,17 +50,18 @@ struct SourceLocation
     unsigned line = 0;
     unsigned column = 0;
     unsigned offset = 0;
-};
-
-inline bool operator==(const SourceLocation &l1, const SourceLocation &l2)
-{ return l1.equals(l2); }
 
-inline bool operator!=(const SourceLocation &l1, const SourceLocation &l2)
-{ return !l1.equals(l2); }
+    friend constexpr bool comparesEqual(const SourceLocation &lhs,
+                                        const SourceLocation &rhs) noexcept
+    {
+        return lhs.file == rhs.file && lhs.offset == rhs.offset;
+    }
+    Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(SourceLocation)
+};
 
 SourceLocation getExpansionLocation(const CXSourceLocation &location);
 
-using SourceRange =QPair<SourceLocation, SourceLocation>;
+using SourceRange = std::pair<SourceLocation, SourceLocation>;
 
 SourceLocation getCursorLocation(const CXCursor &cursor);
 CXString getFileNameFromLocation(const CXSourceLocation &location);
@@ -89,7 +94,7 @@ CXDiagnosticSeverity maxSeverity(const QList<Diagnostic> &ds);
 // with each match (level and string). Return begin and end of the list.
 using TemplateArgumentHandler = std::function<void (int, QStringView)>;
 
-QPair<qsizetype, qsizetype>
+std::pair<qsizetype, qsizetype>
     parseTemplateArgumentList(const QString &l,
                               const TemplateArgumentHandler &handler,
                               qsizetype from = 0);
diff --git a/sources/shiboken6/ApiExtractor/clangparser/compilersupport.cpp b/sources/shiboken6/ApiExtractor/clangparser/compilersupport.cpp
index 4145c8dec..20224020b 100644
--- a/sources/shiboken6/ApiExtractor/clangparser/compilersupport.cpp
+++ b/sources/shiboken6/ApiExtractor/clangparser/compilersupport.cpp
@@ -3,6 +3,7 @@
 
 #include "compilersupport.h"
 #include "header_paths.h"
+#include "clangutils.h"
 
 #include <reporthandler.h>
 
@@ -19,7 +20,6 @@
 
 #include <clang-c/Index.h>
 
-#include <string.h>
 #include <algorithm>
 #include <iterator>
 
@@ -94,13 +94,19 @@ bool setPlatform(const QString &name)
     return result;
 }
 
+// 3/2024: Use a recent MSVC2022 for libclang 18.X
+static QByteArray msvcCompatVersion()
+{
+    return libClangVersion() >= QVersionNumber(0, 64) ? "19.39"_ba : "19.26"_ba;
+}
+
 static bool runProcess(const QString &program, const QStringList &arguments,
                        QByteArray *stdOutIn = nullptr, QByteArray *stdErrIn = nullptr)
 {
     QProcess process;
     process.start(program, arguments, QProcess::ReadWrite);
     if (!process.waitForStarted()) {
-        qWarning().noquote().nospace() << "Unable to start "
+        qCWarning(lcShiboken).noquote().nospace() << "Unable to start "
             << process.program() << ": " << process.errorString();
         return false;
     }
@@ -113,18 +119,18 @@ static bool runProcess(const QString &program, const QStringList &arguments,
         *stdOutIn = process.readAllStandardOutput();
 
     if (!finished) {
-        qWarning().noquote().nospace() << process.program() << " timed out: " << stdErr;
+        qCWarning(lcShiboken).noquote().nospace() << process.program() << " timed out: " << stdErr;
         process.kill();
         return false;
     }
 
     if (process.exitStatus() != QProcess::NormalExit) {
-        qWarning().noquote().nospace() << process.program() << " crashed: " << stdErr;
+        qCWarning(lcShiboken).noquote().nospace() << process.program() << " crashed: " << stdErr;
         return false;
     }
 
     if (process.exitCode() != 0) {
-        qWarning().noquote().nospace() <<  process.program() << " exited "
+        qCWarning(lcShiboken).noquote().nospace() <<  process.program() << " exited "
             << process.exitCode() << ": " << stdErr;
         return false;
     }
@@ -179,6 +185,13 @@ static HeaderPaths gppInternalIncludePaths(const QString &compiler)
         return result;
     const QByteArrayList stdErrLines = stdErr.split('\n');
     bool isIncludeDir = false;
+
+    if (ReportHandler::isDebug(ReportHandler::MediumDebug))
+        qCInfo(lcShiboken()).noquote().nospace()
+            << "gppInternalIncludePaths:\n    compiler: " << compiler
+            << "\n    stdOut: " << stdOut
+            << "\n    stdErr: " << stdErr;
+
     for (const QByteArray &line : stdErrLines) {
         if (isIncludeDir) {
             if (line.startsWith(QByteArrayLiteral("End of search list"))) {
@@ -240,6 +253,23 @@ static bool needsClangBuiltinIncludes()
     return platform() != Platform::macOS;
 }
 
+static QString queryLlvmConfigDir(const QString &arg)
+{
+    static const QString llvmConfig = QStandardPaths::findExecutable(u"llvm-config"_s);
+    if (llvmConfig.isEmpty())
+        return {};
+    QByteArray stdOut;
+    if (!runProcess(llvmConfig, QStringList{arg}, &stdOut))
+        return {};
+    const QString path = QFile::decodeName(stdOut.trimmed());
+    if (!QFileInfo::exists(path)) {
+        qCWarning(lcShiboken, R"(%s: "%s" as returned by llvm-config "%s" does not exist.)",
+                  __FUNCTION__, qPrintable(QDir::toNativeSeparators(path)), qPrintable(arg));
+        return {};
+    }
+    return path;
+}
+
 static QString findClangLibDir()
 {
     for (const char *envVar : {"LLVM_INSTALL_DIR", "CLANG_INSTALL_DIR"}) {
@@ -247,21 +277,11 @@ static QString findClangLibDir()
             const QString path = QFile::decodeName(qgetenv(envVar)) + u"/lib"_s;
             if (QFileInfo::exists(path))
                 return path;
-            qWarning("%s: %s as pointed to by %s does not exist.", __FUNCTION__, qPrintable(path), envVar);
-        }
-    }
-    const QString llvmConfig =
-        QStandardPaths::findExecutable(u"llvm-config"_s);
-    if (!llvmConfig.isEmpty()) {
-        QByteArray stdOut;
-        if (runProcess(llvmConfig, QStringList{u"--libdir"_s}, &stdOut)) {
-            const QString path = QFile::decodeName(stdOut.trimmed());
-            if (QFileInfo::exists(path))
-                return path;
-            qWarning("%s: %s as returned by llvm-config does not exist.", __FUNCTION__, qPrintable(path));
+            qCWarning(lcShiboken, "%s: %s as pointed to by %s does not exist.",
+                      __FUNCTION__, qPrintable(path), envVar);
         }
     }
-    return QString();
+    return queryLlvmConfigDir(u"--libdir"_s);
 }
 
 static QString findClangBuiltInIncludesDir()
@@ -270,13 +290,23 @@ static QString findClangBuiltInIncludesDir()
     const QString clangPathLibDir = findClangLibDir();
     if (!clangPathLibDir.isEmpty()) {
         QString candidate;
+        QString clangDirName = clangPathLibDir + u"/clang"_s;
+        // PYSIDE-2769: llvm-config --libdir may report /usr/lib64 on manylinux_2_28_x86_64
+        // whereas the includes are under /usr/lib/clang/../include.
+        if (!QFileInfo::exists(clangDirName) && clangPathLibDir.endsWith("64"_L1)) {
+            const QString fallback = clangPathLibDir.sliced(0, clangPathLibDir.size() - 2);
+            clangDirName = fallback + u"/clang"_s;
+            qCWarning(lcShiboken, "%s: Falling back from %s to %s.",
+                      __FUNCTION__, qPrintable(clangPathLibDir), qPrintable(fallback));
+        }
+
         QVersionNumber lastVersionNumber(1, 0, 0);
-        const QString clangDirName = clangPathLibDir + u"/clang"_s;
         QDir clangDir(clangDirName);
         const QFileInfoList versionDirs =
             clangDir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
         if (versionDirs.isEmpty())
-            qWarning("%s: No subdirectories found in %s.", __FUNCTION__, qPrintable(clangDirName));
+            qCWarning(lcShiboken, "%s: No subdirectories found in %s.",
+                      __FUNCTION__, qPrintable(clangDirName));
         for (const QFileInfo &fi : versionDirs) {
             const QString fileName = fi.fileName();
             if (fileName.at(0).isDigit()) {
@@ -288,22 +318,44 @@ static QString findClangBuiltInIncludesDir()
             }
         }
         if (!candidate.isEmpty())
-            return candidate + QStringLiteral("/include");
+            return candidate + "/include"_L1;
     }
-    return QString();
+    return queryLlvmConfigDir(u"--includedir"_s);
 }
 
+QString compilerFromCMake()
+{
+#ifdef CMAKE_CXX_COMPILER
+    return QString::fromLocal8Bit(CMAKE_CXX_COMPILER);
+#else
+    return {};
+#endif
+}
+
+// Return a compiler suitable for determining the internal include paths
 static QString compilerFromCMake(const QString &defaultCompiler)
 {
     if (!compilerPath().isEmpty())
         return compilerPath();
-// Added !defined(Q_OS_DARWIN) due to PYSIDE-1032
-    QString result = defaultCompiler;
-#ifdef CMAKE_CXX_COMPILER
-    if (platform() != Platform::macOS)
-        result = QString::fromLocal8Bit(CMAKE_CXX_COMPILER);
-#endif
-    return result;
+    // Exclude macOS since cmakeCompiler returns the full path instead of the
+    // /usr/bin/clang shim, which results in the default SDK sysroot path
+    // missing (PYSIDE-1032)
+    if (platform() == Platform::macOS)
+        return defaultCompiler;
+    QString cmakeCompiler = compilerFromCMake();
+    if (cmakeCompiler.isEmpty())
+        return defaultCompiler;
+    QFileInfo fi(cmakeCompiler);
+    // Should be absolute by default, but a user may specify -DCMAKE_CXX_COMPILER=cl.exe
+    if (fi.isRelative())
+        return cmakeCompiler;
+    if (fi.exists())
+        return fi.absoluteFilePath();
+    // The compiler may not exist in case something like icecream or
+    // a non-standard-path was used on the build machine. Check
+    // the executable.
+    cmakeCompiler = QStandardPaths::findExecutable(fi.fileName());
+    return cmakeCompiler.isEmpty() ? defaultCompiler : cmakeCompiler;
 }
 
 static void appendClangBuiltinIncludes(HeaderPaths *p)
@@ -315,7 +367,8 @@ static void appendClangBuiltinIncludes(HeaderPaths *p)
                   "(neither by checking the environment variables LLVM_INSTALL_DIR, CLANG_INSTALL_DIR "
                   " nor running llvm-config). This may lead to parse errors.");
     } else {
-        qCInfo(lcShiboken, "CLANG builtins includes directory: %s",
+        qCInfo(lcShiboken, "CLANG v%d.%d, builtins includes directory: %s",
+               CINDEX_VERSION_MAJOR, CINDEX_VERSION_MINOR,
                qPrintable(clangBuiltinIncludesDir));
         p->append(HeaderPath{QFile::encodeName(clangBuiltinIncludesDir),
                              HeaderType::System});
@@ -323,15 +376,17 @@ static void appendClangBuiltinIncludes(HeaderPaths *p)
 }
 
 // Returns clang options needed for emulating the host compiler
-QByteArrayList emulatedCompilerOptions()
+QByteArrayList emulatedCompilerOptions(LanguageLevel level)
 {
     QByteArrayList result;
     HeaderPaths headerPaths;
     switch (compiler()) {
     case Compiler::Msvc:
-        result.append(QByteArrayLiteral("-fms-compatibility-version=19.26.28806"));
-        result.append(QByteArrayLiteral("-fdelayed-template-parsing"));
+        result.append("-fms-compatibility-version="_ba + msvcCompatVersion());
+        if (level < LanguageLevel::Cpp20)
+            result.append("-fdelayed-template-parsing"_ba);
         result.append(QByteArrayLiteral("-Wno-microsoft-enum-value"));
+        result.append("/Zc:__cplusplus"_ba);
         // Fix yvals_core.h:  STL1000: Unexpected compiler version, expected Clang 7 or newer (MSVC2017 update)
         result.append(QByteArrayLiteral("-D_ALLOW_COMPILER_AND_STL_VERSION_MISMATCH"));
         if (needsClangBuiltinIncludes())
@@ -347,7 +402,7 @@ QByteArrayList emulatedCompilerOptions()
 
         // Append the c++ include paths since Clang is unable to find
         // <type_traits> etc (g++ 11.3).
-        const HeaderPaths gppPaths = gppInternalIncludePaths(compilerFromCMake(u"g++"_qs));
+        const HeaderPaths gppPaths = gppInternalIncludePaths(compilerFromCMake(u"g++"_s));
         for (const HeaderPath &h : gppPaths) {
             if (h.path.contains("c++") || h.path.contains("sysroot"))
                 headerPaths.append(h);
diff --git a/sources/shiboken6/ApiExtractor/clangparser/compilersupport.h b/sources/shiboken6/ApiExtractor/clangparser/compilersupport.h
index 18e87c495..f1d63b7c3 100644
--- a/sources/shiboken6/ApiExtractor/clangparser/compilersupport.h
+++ b/sources/shiboken6/ApiExtractor/clangparser/compilersupport.h
@@ -33,7 +33,7 @@ enum class Platform {
 namespace clang {
 QVersionNumber libClangVersion();
 
-QByteArrayList emulatedCompilerOptions();
+QByteArrayList emulatedCompilerOptions(LanguageLevel level);
 LanguageLevel emulatedCompilerLanguageLevel();
 
 const char *languageLevelOption(LanguageLevel l);
@@ -44,6 +44,8 @@ QByteArrayList detectVulkan();
 Compiler compiler();
 bool setCompiler(const QString &name);
 
+QString compilerFromCMake();
+
 const QString &compilerPath();
 void setCompilerPath(const QString &name);
 
diff --git a/sources/shiboken6/ApiExtractor/classdocumentation.cpp b/sources/shiboken6/ApiExtractor/classdocumentation.cpp
index 3d4abb87d..637e4a422 100644
--- a/sources/shiboken6/ApiExtractor/classdocumentation.cpp
+++ b/sources/shiboken6/ApiExtractor/classdocumentation.cpp
@@ -3,6 +3,7 @@
 
 #include "classdocumentation.h"
 #include "messages.h"
+#include "debughelpers_p.h"
 
 #include <QtCore/QDebug>
 #include <QtCore/QBuffer>
@@ -82,44 +83,51 @@ qsizetype ClassDocumentation::indexOfProperty(const QString &name) const
     return -1;
 }
 
-enum class WebXmlTag
+enum class WebXmlCodeTag
 {
-    Class, Description, Enum, Function, Parameter, Property, Typedef, Other
+    Class, Description, Enum, Function, Header, Parameter, Property, Typedef, Other
 };
 
-static WebXmlTag tag(QStringView name)
+static WebXmlCodeTag tag(QStringView name)
 {
     if (name == u"class" || name == u"namespace")
-        return WebXmlTag::Class;
+        return WebXmlCodeTag::Class;
     if (name == u"enum")
-        return WebXmlTag::Enum;
+        return WebXmlCodeTag::Enum;
     if (name == u"function")
-        return WebXmlTag::Function;
+        return WebXmlCodeTag::Function;
     if (name == u"description")
-        return WebXmlTag::Description;
+        return WebXmlCodeTag::Description;
+    if (name == u"header")
+        return WebXmlCodeTag::Header;
     if (name == u"parameter")
-        return WebXmlTag::Parameter;
+        return WebXmlCodeTag::Parameter;
     if (name == u"property")
-        return WebXmlTag::Property;
+        return WebXmlCodeTag::Property;
     if (name == u"typedef")
-        return WebXmlTag::Typedef;
-    return WebXmlTag::Other;
+        return WebXmlCodeTag::Typedef;
+    return WebXmlCodeTag::Other;
 }
 
-static void parseWebXmlElement(WebXmlTag tag, const QXmlStreamAttributes &attributes,
+static void parseWebXmlElement(WebXmlCodeTag tag, const QXmlStreamAttributes &attributes,
                                ClassDocumentation *cd)
 {
     switch (tag) {
-    case WebXmlTag::Class:
+    case WebXmlCodeTag::Class:
         cd->name = attributes.value(u"name"_s).toString();
+        cd->type = ClassDocumentation::Class;
         break;
-    case WebXmlTag::Enum: {
+    case WebXmlCodeTag::Header:
+        cd->name = attributes.value(u"name"_s).toString();
+        cd->type = ClassDocumentation::Header;
+        break;
+    case WebXmlCodeTag::Enum: {
         EnumDocumentation ed;
         ed.name = attributes.value(u"name"_s).toString();
         cd->enums.append(ed);
     }
         break;
-    case WebXmlTag::Function: {
+    case WebXmlCodeTag::Function: {
         FunctionDocumentation fd;
         fd.name = attributes.value(u"name"_s).toString();
         fd.signature = attributes.value(u"signature"_s).toString();
@@ -128,11 +136,11 @@ static void parseWebXmlElement(WebXmlTag tag, const QXmlStreamAttributes &attrib
         cd->functions.append(fd);
     }
         break;
-    case WebXmlTag::Parameter:
+    case WebXmlCodeTag::Parameter:
         Q_ASSERT(!cd->functions.isEmpty());
         cd->functions.last().parameters.append(attributes.value(u"type"_s).toString());
         break;
-    case WebXmlTag::Property: {
+    case WebXmlCodeTag::Property: {
         PropertyDocumentation pd;
         pd.name = attributes.value(u"name"_s).toString();
         pd.brief = attributes.value(u"brief"_s).toString();
@@ -184,17 +192,17 @@ static QString msgXmlError(const QString &fileName, const QXmlStreamReader &read
     return result;
 }
 
-ClassDocumentation parseWebXml(const QString &fileName, QString *errorMessage)
+std::optional<ClassDocumentation> parseWebXml(const QString &fileName, QString *errorMessage)
 {
     ClassDocumentation result;
 
     QFile file(fileName);
     if (!file.open(QIODevice::Text | QIODevice::ReadOnly)) {
         *errorMessage = msgCannotOpenForReading(file);
-        return result;
+        return std::nullopt;
     }
 
-    WebXmlTag lastTag = WebXmlTag::Other;
+    WebXmlCodeTag lastTag = WebXmlCodeTag::Other;
     QXmlStreamReader reader(&file);
     while (!reader.atEnd()) {
         switch (reader.readNext()) {
@@ -202,26 +210,27 @@ ClassDocumentation parseWebXml(const QString &fileName, QString *errorMessage)
             const auto currentTag = tag(reader.name());
             parseWebXmlElement(currentTag, reader.attributes(), &result);
             switch (currentTag) { // Store relevant tags in lastTag
-            case WebXmlTag::Class:
-            case WebXmlTag::Function:
-            case WebXmlTag::Enum:
-            case WebXmlTag::Property:
-            case WebXmlTag::Typedef:
+            case WebXmlCodeTag::Class:
+            case WebXmlCodeTag::Function:
+            case WebXmlCodeTag::Enum:
+            case WebXmlCodeTag::Header:
+            case WebXmlCodeTag::Property:
+            case WebXmlCodeTag::Typedef:
                 lastTag = currentTag;
                 break;
-            case WebXmlTag::Description: { // Append the description to the element
+            case WebXmlCodeTag::Description: { // Append the description to the element
                 QString *target = nullptr;
                 switch (lastTag) {
-                case WebXmlTag::Class:
+                case WebXmlCodeTag::Class:
                     target = &result.description;
                     break;
-                case WebXmlTag::Function:
+                case WebXmlCodeTag::Function:
                     target = &result.functions.last().description;
                     break;
-                case WebXmlTag::Enum:
+                case WebXmlCodeTag::Enum:
                     target = &result.enums.last().description;
                     break;
-                case WebXmlTag::Property:
+                case WebXmlCodeTag::Property:
                     target = &result.properties.last().description;
                 default:
                     break;
@@ -241,7 +250,7 @@ ClassDocumentation parseWebXml(const QString &fileName, QString *errorMessage)
 
     if (reader.error() != QXmlStreamReader::NoError) {
         *errorMessage= msgXmlError(fileName, reader);
-        return {};
+        return std::nullopt;
     }
 
     sortDocumentation(&result);
@@ -277,21 +286,6 @@ QString webXmlModuleDescription(const QString &fileName, QString *errorMessage)
     return result;
 }
 
-// Debug helpers
-template <class T>
-static void formatList(QDebug &debug, const char *title, const QList<T> &l)
-{
-    if (const qsizetype size = l.size()) {
-        debug << title << '[' << size << "]=(";
-        for (qsizetype i = 0; i < size; ++i) {
-            if (i)
-                debug << ", ";
-            debug << l.at(i);
-        }
-        debug << ')';
-    }
-}
-
 static void formatDescription(QDebug &debug, const QString &desc)
 {
     debug << "description=";
@@ -351,7 +345,7 @@ QDebug operator<<(QDebug debug, const FunctionDocumentation &f)
             debug << ", returns " << f.returnType;
         if (f.constant)
             debug << ", const";
-        formatList(debug, ", parameters", f.parameters);
+        formatList(debug, ", parameters", f.parameters, ", ");
         debug << ", signature=\"" << f.signature << "\", ";
         formatDescription(debug, f.description);
     }
@@ -377,16 +371,11 @@ QDebug operator<<(QDebug debug, const ClassDocumentation &c)
     QDebugStateSaver saver(debug);
     debug.noquote();
     debug.nospace();
-    debug << "Class(";
-    if (c) {
-        debug << c.name << ", ";
-        formatDescription(debug, c.description);
-        formatList(debug, ", enums", c.enums);
-        formatList(debug, ", properties", c.properties);
-        formatList(debug, ", functions", c.functions);
-    } else {
-        debug << "invalid";
-    }
+    debug << "Class(" << c.name << ", ";
+    formatDescription(debug, c.description);
+    formatList(debug, ", enums", c.enums);
+    formatList(debug, ", properties", c.properties);
+    formatList(debug, ", functions", c.functions);
     debug << ')';
     return debug;
 }
diff --git a/sources/shiboken6/ApiExtractor/classdocumentation.h b/sources/shiboken6/ApiExtractor/classdocumentation.h
index ef66912f8..d47101389 100644
--- a/sources/shiboken6/ApiExtractor/classdocumentation.h
+++ b/sources/shiboken6/ApiExtractor/classdocumentation.h
@@ -6,6 +6,8 @@
 
 #include <QtCore/QStringList>
 
+#include <optional>
+
 QT_FORWARD_DECLARE_CLASS(QDebug)
 
 /// An enumeration in a WebXML/doxygen document
@@ -41,9 +43,14 @@ struct FunctionDocumentation : public FunctionDocumentationQuery
 
 using FunctionDocumentationList = QList<FunctionDocumentation>;
 
-/// A class/namespace in a WebXML/doxygen document
+/// A WebXML/doxygen document
 struct ClassDocumentation
 {
+    enum Type {
+        Class, // <class>, class/namespace
+        Header // <header>, grouped global functions/enums
+    };
+
     qsizetype indexOfEnum(const QString &name) const;
     FunctionDocumentationList findFunctionCandidates(const QString &name,
                                                      bool constant) const;
@@ -51,18 +58,17 @@ struct ClassDocumentation
                                      const FunctionDocumentationQuery &q);
     qsizetype indexOfProperty(const QString &name) const;
 
+    Type type = Type::Class;
     QString name;
     QString description;
 
     QList<EnumDocumentation> enums;
     QList<PropertyDocumentation> properties;
     FunctionDocumentationList functions;
-
-    operator bool() const { return !name.isEmpty(); }
 };
 
 /// Parse a WebXML class/namespace document
-ClassDocumentation parseWebXml(const QString &fileName, QString *errorMessage);
+std::optional<ClassDocumentation> parseWebXml(const QString &fileName, QString *errorMessage);
 
 /// Extract the module description from a WebXML module document
 QString webXmlModuleDescription(const QString &fileName, QString *errorMessage);
diff --git a/sources/shiboken6/ApiExtractor/cmake_uninstall.cmake b/sources/shiboken6/ApiExtractor/cmake_uninstall.cmake
index df95fb9d8..4031b4e1a 100644
--- a/sources/shiboken6/ApiExtractor/cmake_uninstall.cmake
+++ b/sources/shiboken6/ApiExtractor/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/shiboken6/ApiExtractor/codesnip.cpp b/sources/shiboken6/ApiExtractor/codesnip.cpp
index 81977ceb1..e2cd5eb35 100644
--- a/sources/shiboken6/ApiExtractor/codesnip.cpp
+++ b/sources/shiboken6/ApiExtractor/codesnip.cpp
@@ -14,7 +14,7 @@ using namespace Qt::StringLiterals;
 QString TemplateInstance::expandCode() const
 {
     const auto templateEntry = TypeDatabase::instance()->findTemplate(m_name);
-    if (templateEntry.isNull()) {
+    if (!templateEntry) {
         const QString m = u"<insert-template> referring to non-existing template '"_s
                           + m_name + u"'."_s;
         throw Exception(m);
@@ -63,7 +63,7 @@ void CodeSnipAbstract::purgeEmptyFragments()
 
 QRegularExpression CodeSnipAbstract::placeHolderRegex(int index)
 {
-    return QRegularExpression(u'%' + QString::number(index) + QStringLiteral("\\b"));
+    return QRegularExpression(u'%' + QString::number(index) + "\\b"_L1);
 }
 
 void purgeEmptyCodeSnips(QList<CodeSnip> *list)
diff --git a/sources/shiboken6/ApiExtractor/codesnip.h b/sources/shiboken6/ApiExtractor/codesnip.h
index 7a1ab0624..86834a1db 100644
--- a/sources/shiboken6/ApiExtractor/codesnip.h
+++ b/sources/shiboken6/ApiExtractor/codesnip.h
@@ -9,9 +9,10 @@
 
 #include <QtCore/QList>
 #include <QtCore/QHash>
-#include <QtCore/QSharedPointer>
 #include <QtCore/QString>
 
+#include <memory>
+
 class TemplateInstance
 {
 public:
@@ -34,7 +35,7 @@ private:
     QHash<QString, QString> replaceRules;
 };
 
-using TemplateInstancePtr = QSharedPointer<TemplateInstance>;
+using TemplateInstancePtr = std::shared_ptr<TemplateInstance>;
 
 class CodeSnipFragment
 {
@@ -43,7 +44,7 @@ public:
     explicit CodeSnipFragment(const QString &code) : m_code(code) {}
     explicit CodeSnipFragment(const TemplateInstancePtr &instance) : m_instance(instance) {}
 
-    bool isEmpty() const { return m_code.isEmpty() && m_instance.isNull(); }
+    bool isEmpty() const { return m_code.isEmpty() && !m_instance; }
 
     QString code() const;
 
@@ -51,7 +52,7 @@ public:
 
 private:
     QString m_code;
-    QSharedPointer<TemplateInstance> m_instance;
+    std::shared_ptr<TemplateInstance> m_instance;
 };
 
 class CodeSnipAbstract : public CodeSnipHelpers
diff --git a/sources/shiboken6/ApiExtractor/complextypeentry.h b/sources/shiboken6/ApiExtractor/complextypeentry.h
index bdbd7fa22..5b884f2cc 100644
--- a/sources/shiboken6/ApiExtractor/complextypeentry.h
+++ b/sources/shiboken6/ApiExtractor/complextypeentry.h
@@ -4,7 +4,7 @@
 #ifndef COMPLEXTYPEENTRY_H
 #define COMPLEXTYPEENTRY_H
 
-#include "typesystem.h"
+#include "configurabletypeentry.h"
 #include "typesystem_enums.h"
 #include "modifications_typedefs.h"
 #include "pymethoddefentry.h"
@@ -33,7 +33,7 @@ struct TypeSystemProperty
     bool generateGetSetDef = false;
 };
 
-class ComplexTypeEntry : public TypeEntry
+class ComplexTypeEntry : public ConfigurableTypeEntry
 {
 public:
     enum TypeFlag {
@@ -42,7 +42,9 @@ public:
         ForceAbstract      = 0x8,
         // Indicates that the instances are used to create hierarchies
         // like widgets; parent ownership heuristics are enabled for them.
-        ParentManagement   = 0x10
+        ParentManagement   = 0x10,
+        DisableQtMetaObjectFunctions = 0x20,
+        Typedef = 0x40 // Result of a <typedef-type>
     };
     Q_DECLARE_FLAGS(TypeFlags, TypeFlag)
 
diff --git a/sources/shiboken6/ApiExtractor/conditionalstreamreader.cpp b/sources/shiboken6/ApiExtractor/conditionalstreamreader.cpp
index c02a95777..b6eda651c 100644
--- a/sources/shiboken6/ApiExtractor/conditionalstreamreader.cpp
+++ b/sources/shiboken6/ApiExtractor/conditionalstreamreader.cpp
@@ -165,15 +165,15 @@ QStringList ConditionalStreamReader::platformConditions()
 {
     QStringList result;
 #if defined (Q_OS_UNIX)
-    result << QStringLiteral("unix");
+    result << "unix"_L1;
 #endif
 
 #if defined (Q_OS_LINUX)
-    result << QStringLiteral("linux");
+    result << "linux"_L1;
 #elif defined (Q_OS_MACOS)
-    result << QStringLiteral("darwin");
+    result << "darwin"_L1;
 #elif defined (Q_OS_WINDOWS)
-    result << QStringLiteral("windows");
+    result << "windows"_L1;
 #endif
     return result;
 }
diff --git a/sources/shiboken6/ApiExtractor/conditionalstreamreader.h b/sources/shiboken6/ApiExtractor/conditionalstreamreader.h
index a273fd0ca..730697525 100644
--- a/sources/shiboken6/ApiExtractor/conditionalstreamreader.h
+++ b/sources/shiboken6/ApiExtractor/conditionalstreamreader.h
@@ -26,6 +26,8 @@ class ProxyEntityResolver;
 class ConditionalStreamReader
 {
 public:
+    Q_DISABLE_COPY_MOVE(ConditionalStreamReader)
+
     using TokenType = QXmlStreamReader::TokenType;
     explicit ConditionalStreamReader(QIODevice *iod);
     explicit ConditionalStreamReader(const QString &s);
diff --git a/sources/shiboken6/ApiExtractor/configurabletypeentry.h b/sources/shiboken6/ApiExtractor/configurabletypeentry.h
new file mode 100644
index 000000000..59522e16c
--- /dev/null
+++ b/sources/shiboken6/ApiExtractor/configurabletypeentry.h
@@ -0,0 +1,28 @@
+// 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 CONFIGURABLETYPEENTRY_H
+#define CONFIGURABLETYPEENTRY_H
+
+#include "typesystem.h"
+
+class ConfigurableTypeEntryPrivate;
+
+class ConfigurableTypeEntry : public TypeEntry
+{
+public:
+    explicit ConfigurableTypeEntry(const QString &entryName, Type t,
+                                   const QVersionNumber &vr,
+                                   const TypeEntryCPtr &parent);
+
+    TypeEntry *clone() const override;
+
+    QString configCondition() const;
+    void setConfigCondition(const QString &c);
+    bool hasConfigCondition() const;
+
+protected:
+    explicit ConfigurableTypeEntry(ConfigurableTypeEntryPrivate *d);
+};
+
+#endif // CONFIGURABLETYPEENTRY_H
diff --git a/sources/shiboken6/ApiExtractor/containertypeentry.h b/sources/shiboken6/ApiExtractor/containertypeentry.h
index 8acf038fd..b2003816b 100644
--- a/sources/shiboken6/ApiExtractor/containertypeentry.h
+++ b/sources/shiboken6/ApiExtractor/containertypeentry.h
@@ -9,15 +9,19 @@
 
 class ContainerTypeEntryPrivate;
 
+struct OpaqueContainer // Generate an opaque container for an instantiation under name
+{
+    QStringList instantiations;
+    QString name;
+
+    QString templateParameters() const;
+};
+
+using OpaqueContainers = QList<OpaqueContainer>;
+
 class ContainerTypeEntry : public ComplexTypeEntry
 {
 public:
-    struct OpaqueContainer // Generate an opaque container for an instantiation under name
-    {
-        QString instantiation;
-        QString name;
-    };
-    using OpaqueContainers = QList<OpaqueContainer>;
 
     enum ContainerKind {
         ListContainer,
@@ -25,6 +29,7 @@ public:
         MapContainer,
         MultiMapContainer,
         PairContainer,
+        SpanContainer, // Fixed size
     };
 
     explicit ContainerTypeEntry(const QString &entryName, ContainerKind containerKind,
@@ -32,10 +37,13 @@ public:
 
     ContainerKind containerKind() const;
 
+    /// Number of template parameters (except allocators)
+    qsizetype templateParameterCount() const;
+
     const OpaqueContainers &opaqueContainers() const;
-    void addOpaqueContainer(OpaqueContainer r);
-    bool generateOpaqueContainer(const QString &instantiation) const;
-    QString opaqueContainerName(const QString &instantiation) const;
+    void appendOpaqueContainers(const OpaqueContainers &l);
+    bool generateOpaqueContainer(const QStringList &instantiations) const;
+    QString opaqueContainerName(const QStringList &instantiations) const;
 
     bool hasCustomConversion() const;
     void setCustomConversion(const CustomConversionPtr &customConversion);
@@ -50,4 +58,6 @@ protected:
     explicit ContainerTypeEntry(ContainerTypeEntryPrivate *d);
 };
 
+QDebug operator<<(QDebug d, const OpaqueContainer &oc);
+
 #endif // CONTAINERTYPEENTRY_H
diff --git a/sources/shiboken6/ApiExtractor/customconversion.cpp b/sources/shiboken6/ApiExtractor/customconversion.cpp
index 4632e4e76..4cfd1b974 100644
--- a/sources/shiboken6/ApiExtractor/customconversion.cpp
+++ b/sources/shiboken6/ApiExtractor/customconversion.cpp
@@ -99,7 +99,7 @@ QString TargetToNativeConversion::sourceTypeCheck() const
         return m_sourceTypeCheck;
 
     if (m_sourceType != nullptr && m_sourceType->isCustom()) {
-        const auto cte = qSharedPointerCast<const CustomTypeEntry>(m_sourceType);
+        const auto cte = std::static_pointer_cast<const CustomTypeEntry>(m_sourceType);
         if (cte->hasCheckFunction()) {
             QString result = cte->checkFunction();
             if (result != u"true") // For PyObject, which is always true
@@ -134,11 +134,11 @@ void TargetToNativeConversion::formatDebug(QDebug &debug) const
 CustomConversionPtr CustomConversion::getCustomConversion(const TypeEntryCPtr &type)
 {
     if (type->isPrimitive())
-        return qSharedPointerCast<const PrimitiveTypeEntry>(type)->customConversion();
+        return std::static_pointer_cast<const PrimitiveTypeEntry>(type)->customConversion();
     if (type->isContainer())
-        return qSharedPointerCast<const ContainerTypeEntry>(type)->customConversion();
+        return std::static_pointer_cast<const ContainerTypeEntry>(type)->customConversion();
     if (type->isValue())
-        return qSharedPointerCast<const ValueTypeEntry>(type)->customConversion();
+        return std::static_pointer_cast<const ValueTypeEntry>(type)->customConversion();
     return {};
 }
 
@@ -188,7 +188,7 @@ QDebug operator<<(QDebug debug, const CustomConversionPtr &cptr)
     debug.noquote();
     debug.nospace();
     debug << "CustomConversionPtr";
-    if (auto *c = cptr.data()) {
+    if (auto *c = cptr.get()) {
         c->formatDebug(debug);
     } else {
         debug << "(0)";
diff --git a/sources/shiboken6/ApiExtractor/customconversion_typedefs.h b/sources/shiboken6/ApiExtractor/customconversion_typedefs.h
index a928378b7..6528f7d7b 100644
--- a/sources/shiboken6/ApiExtractor/customconversion_typedefs.h
+++ b/sources/shiboken6/ApiExtractor/customconversion_typedefs.h
@@ -5,9 +5,10 @@
 #define CUSTOMCONVERSION_TYPEDEFS_H
 
 #include <QtCore/QList>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
 
 class CustomConversion;
-using CustomConversionPtr = QSharedPointer<CustomConversion>;
+using CustomConversionPtr = std::shared_ptr<CustomConversion>;
 
 #endif // CUSTOMCONVERSION_TYPEDEFS_H
diff --git a/sources/shiboken6/ApiExtractor/debughelpers_p.h b/sources/shiboken6/ApiExtractor/debughelpers_p.h
new file mode 100644
index 000000000..81ebbb3b9
--- /dev/null
+++ b/sources/shiboken6/ApiExtractor/debughelpers_p.h
@@ -0,0 +1,56 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef DEBUGHELPERS_P_H
+#define DEBUGHELPERS_P_H
+
+#include <QtCore/QDebug>
+#include <memory>
+
+template <class T>
+inline QDebug operator<<(QDebug debug, const std::shared_ptr<T> &ptr)
+{
+    QDebugStateSaver saver(debug);
+    debug.nospace();
+    debug << "std::shared_ptr(" << ptr.get() << ")";
+    return debug;
+}
+
+template <class It>
+inline void formatSequence(QDebug &d, It i1, It i2,
+                           const char *separator=", ")
+{
+    for (It i = i1; i != i2; ++i) {
+        if (i != i1)
+            d << separator;
+        d << *i;
+    }
+}
+
+template <class It>
+inline static void formatPtrSequence(QDebug &d, It i1, It i2,
+                                     const char *separator=", ")
+{
+    for (It i = i1; i != i2; ++i) {
+        if (i != i1)
+            d << separator;
+        d << i->get();
+    }
+}
+
+template <class Container>
+static void formatList(QDebug &d, const char *name, const Container &c,
+                       const char *separator=", ")
+{
+    if (const auto size = c.size()) {
+        d << ", " << name << '[' << size << "]=(";
+        for (qsizetype i = 0; i < size; ++i) {
+            if (i)
+                d << separator;
+             d << c.at(i);
+        }
+        d << ')';
+    }
+}
+
+#endif // DEBUGHELPERS_P_H
diff --git a/sources/shiboken6/ApiExtractor/dependency.h b/sources/shiboken6/ApiExtractor/dependency.h
index f0e525e26..aa280de03 100644
--- a/sources/shiboken6/ApiExtractor/dependency.h
+++ b/sources/shiboken6/ApiExtractor/dependency.h
@@ -13,8 +13,8 @@
 class AbstractMetaClass;
 
 struct Dependency {
-    AbstractMetaClass *parent;
-    AbstractMetaClass *child;
+    AbstractMetaClassPtr parent;
+    AbstractMetaClassPtr child;
 };
 
 using Dependencies = QList<Dependency>;
diff --git a/sources/shiboken6/ApiExtractor/docparser.cpp b/sources/shiboken6/ApiExtractor/docparser.cpp
index 908e8576b..468fe1098 100644
--- a/sources/shiboken6/ApiExtractor/docparser.cpp
+++ b/sources/shiboken6/ApiExtractor/docparser.cpp
@@ -31,15 +31,37 @@
 
 using namespace Qt::StringLiterals;
 
-DocParser::DocParser()
+static inline bool isXpathDocModification(const DocModification &mod)
 {
-#ifdef HAVE_LIBXSLT
-    xmlSubstituteEntitiesDefault(1);
-#endif
+    return mod.mode() == TypeSystem::DocModificationXPathReplace;
 }
 
+static inline bool isNotXpathDocModification(const DocModification &mod)
+{
+    return mod.mode() != TypeSystem::DocModificationXPathReplace;
+}
+
+static void removeXpathDocModifications(DocModificationList *l)
+{
+    l->erase(std::remove_if(l->begin(), l->end(), isXpathDocModification), l->end());
+}
+
+static void removeNonXpathDocModifications(DocModificationList *l)
+{
+    l->erase(std::remove_if(l->begin(), l->end(), isNotXpathDocModification), l->end());
+}
+
+DocParser::DocParser() = default;
 DocParser::~DocParser() = default;
 
+void DocParser::fillGlobalFunctionDocumentation(const AbstractMetaFunctionPtr &)
+{
+}
+
+void DocParser::fillGlobalEnumDocumentation(AbstractMetaEnum &)
+{
+}
+
 QString DocParser::getDocumentation(const XQueryPtr &xquery, const QString& query,
                                     const DocModificationList& mods)
 {
@@ -86,22 +108,59 @@ bool DocParser::skipForQuery(const AbstractMetaFunctionCPtr &func)
                        usesRValueReference);
 }
 
-DocModificationList DocParser::getDocModifications(const AbstractMetaClass *cppClass,
-                                                   const AbstractMetaFunctionCPtr &func)
+DocModificationList DocParser::getDocModifications(const AbstractMetaClassCPtr &cppClass)
+
+{
+    auto result = cppClass->typeEntry()->docModifications();
+    removeXpathDocModifications(&result);
+    return result;
+}
+
+static void filterBySignature(const AbstractMetaFunctionCPtr &func, DocModificationList *l)
 {
-    auto te = cppClass->typeEntry();
-    if (func.isNull())
-        return te->docModifications();
+    if (!l->isEmpty()) {
+        const QString minimalSignature = func->minimalSignature();
+        const auto filter = [&minimalSignature](const DocModification &mod) {
+            return mod.signature() != minimalSignature;
+        };
+        l->erase(std::remove_if(l->begin(), l->end(), filter), l->end());
+    }
+}
 
-    if (func->isUserAdded())
-        return func->addedFunctionDocModifications();
+DocModificationList DocParser::getDocModifications(const AbstractMetaFunctionCPtr &func,
+                                                   const AbstractMetaClassCPtr &cppClass)
+{
+    DocModificationList result;
+    if (func->isUserAdded()) {
+        result = func->addedFunctionDocModifications();
+        removeXpathDocModifications(&result);
+    } else if (cppClass != nullptr) {
+        result = cppClass->typeEntry()->functionDocModifications();
+        removeXpathDocModifications(&result);
+        filterBySignature(func, &result);
+    }
+    return result;
+}
 
-    DocModificationList result = te->functionDocModifications();
-    const QString minimalSignature = func->minimalSignature();
-    const auto filter = [&minimalSignature](const DocModification &mod) {
-        return mod.signature() != minimalSignature;
-    };
-    result.erase(std::remove_if(result.begin(), result.end(), filter), result.end());
+DocModificationList DocParser::getXpathDocModifications(const AbstractMetaClassCPtr &cppClass)
+{
+    auto result = cppClass->typeEntry()->docModifications();
+    removeNonXpathDocModifications(&result);
+    return result;
+}
+
+DocModificationList DocParser::getXpathDocModifications(const AbstractMetaFunctionCPtr &func,
+                                                        const AbstractMetaClassCPtr &cppClass)
+{
+    DocModificationList result;
+    if (func->isUserAdded()) {
+        result = func->addedFunctionDocModifications();
+        removeNonXpathDocModifications(&result);
+    } else if (cppClass != nullptr) {
+        result = cppClass->typeEntry()->functionDocModifications();
+        removeNonXpathDocModifications(&result);
+        filterBySignature(func, &result);
+    }
     return result;
 }
 
@@ -120,7 +179,7 @@ QString DocParser::enumBaseClass(const AbstractMetaEnum &e)
     return e.typeEntry()->flags() != nullptr ? u"Flag"_s : u"Enum"_s;
 }
 
-AbstractMetaFunctionCList DocParser::documentableFunctions(const AbstractMetaClass *metaClass)
+AbstractMetaFunctionCList DocParser::documentableFunctions(const AbstractMetaClassCPtr &metaClass)
 {
     auto result = metaClass->functionsInTargetLang();
     for (auto i = result.size() - 1; i >= 0; --i)  {
@@ -131,12 +190,8 @@ AbstractMetaFunctionCList DocParser::documentableFunctions(const AbstractMetaCla
     return result;
 }
 
-static inline bool isXpathDocModification(const DocModification &mod)
-{
-    return mod.mode() == TypeSystem::DocModificationXPathReplace;
-}
-
-QString DocParser::applyDocModifications(const DocModificationList& mods, const QString& xml)
+QString DocParser::applyDocModifications(const DocModificationList& xpathMods,
+                                         const QString& xml)
 {
     const char xslPrefix[] =
 R"(<xsl:template match="/">
@@ -150,32 +205,28 @@ R"(<xsl:template match="/">
 </xsl:template>
 )";
 
-    if (mods.isEmpty() || xml.isEmpty()
-        || !std::any_of(mods.cbegin(), mods.cend(), isXpathDocModification)) {
+    if (xpathMods.isEmpty() || xml.isEmpty())
         return xml;
-    }
 
     QString xsl = QLatin1StringView(xslPrefix);
-    for (const DocModification &mod : mods) {
-        if (isXpathDocModification(mod)) {
-            QString xpath = mod.xpath();
-            xpath.replace(u'"', u"&quot;"_s);
-            xsl += u"<xsl:template match=\""_s
-                   + xpath + u"\">"_s
-                   + mod.code() + u"</xsl:template>\n"_s;
-        }
+    for (const DocModification &mod : xpathMods) {
+        Q_ASSERT(isXpathDocModification(mod));
+        QString xpath = mod.xpath();
+        xpath.replace(u'"', u"&quot;"_s);
+        xsl += "<xsl:template match=\""_L1 + xpath + "\">"_L1
+               + mod.code() + "</xsl:template>\n"_L1;
     }
 
     QString errorMessage;
     const QString result = xsl_transform(xml, xsl, &errorMessage);
     if (!errorMessage.isEmpty())
         qCWarning(lcShibokenDoc, "%s",
-                  qPrintable(msgXpathDocModificationError(mods, errorMessage)));
+                  qPrintable(msgXpathDocModificationError(xpathMods, errorMessage)));
     if (result == xml) {
         const QString message = u"Query did not result in any modifications to \""_s
             + xml + u'"';
         qCWarning(lcShibokenDoc, "%s",
-                  qPrintable(msgXpathDocModificationError(mods, message)));
+                  qPrintable(msgXpathDocModificationError(xpathMods, message)));
     }
     return result;
 }
diff --git a/sources/shiboken6/ApiExtractor/docparser.h b/sources/shiboken6/ApiExtractor/docparser.h
index 88643b7bf..6d458b25a 100644
--- a/sources/shiboken6/ApiExtractor/docparser.h
+++ b/sources/shiboken6/ApiExtractor/docparser.h
@@ -7,7 +7,8 @@
 #include "modifications_typedefs.h"
 
 #include <QtCore/QString>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
 
 class AbstractMetaClass;
 class DocModification;
@@ -20,13 +21,15 @@ struct FunctionDocumentation;
 class DocParser
 {
 public:
-    Q_DISABLE_COPY(DocParser)
+    Q_DISABLE_COPY_MOVE(DocParser)
 
-    using XQueryPtr = QSharedPointer<XQuery>;
+    using XQueryPtr = std::shared_ptr<XQuery>;
 
     DocParser();
     virtual ~DocParser();
-    virtual void fillDocumentation(AbstractMetaClass *metaClass) = 0;
+    virtual void fillDocumentation(const AbstractMetaClassPtr &metaClass) = 0;
+    virtual void fillGlobalFunctionDocumentation(const AbstractMetaFunctionPtr &f);
+    virtual void fillGlobalEnumDocumentation(AbstractMetaEnum &e);
 
     /**
      *   Process and retrieves documentation concerning the entire
@@ -93,8 +96,12 @@ public:
 
     /// Helper to return the documentation modifications for a class
     /// or a member function.
-    static DocModificationList getDocModifications(const AbstractMetaClass *cppClass,
-                                                   const AbstractMetaFunctionCPtr &func = {});
+    static DocModificationList getDocModifications(const AbstractMetaClassCPtr &cppClass);
+    static DocModificationList getDocModifications(const AbstractMetaFunctionCPtr &func,
+                                                   const AbstractMetaClassCPtr &cppClass = {});
+    static DocModificationList getXpathDocModifications(const AbstractMetaClassCPtr &cppClass);
+    static DocModificationList getXpathDocModifications(const AbstractMetaFunctionCPtr &func,
+                                                        const AbstractMetaClassCPtr &cppClass = {});
 
     static QString enumBaseClass(const AbstractMetaEnum &e);
 
@@ -103,9 +110,9 @@ protected:
                                     const QString &query,
                                     const DocModificationList &mods);
 
-    static AbstractMetaFunctionCList documentableFunctions(const AbstractMetaClass *metaClass);
+    static AbstractMetaFunctionCList documentableFunctions(const AbstractMetaClassCPtr &metaClass);
 
-    static QString applyDocModifications(const DocModificationList &mods, const QString &xml);
+    static QString applyDocModifications(const DocModificationList &xpathMods, const QString &xml);
 
 private:
     QString m_packageName;
diff --git a/sources/shiboken6/ApiExtractor/documentation.cpp b/sources/shiboken6/ApiExtractor/documentation.cpp
index 6c4d7166e..33cf0e9fb 100644
--- a/sources/shiboken6/ApiExtractor/documentation.cpp
+++ b/sources/shiboken6/ApiExtractor/documentation.cpp
@@ -35,12 +35,6 @@ void Documentation::setFormat(Documentation::Format f)
     m_format = f;
 }
 
-bool Documentation::equals(const Documentation &rhs) const
-{
-    return m_format == rhs.m_format && m_detailed == rhs.m_detailed
-        && m_brief == rhs.m_brief;
-}
-
 void Documentation::setDetailed(const QString &detailed)
 {
     m_detailed = detailed.trimmed();
diff --git a/sources/shiboken6/ApiExtractor/documentation.h b/sources/shiboken6/ApiExtractor/documentation.h
index a18bb1a13..df9d5d614 100644
--- a/sources/shiboken6/ApiExtractor/documentation.h
+++ b/sources/shiboken6/ApiExtractor/documentation.h
@@ -5,6 +5,7 @@
 #define DOCUMENTATION_H
 
 #include <QtCore/QString>
+#include <QtCore/QtCompare>
 
 QT_FORWARD_DECLARE_CLASS(QDebug)
 
@@ -44,16 +45,19 @@ public:
     void setBrief(const QString &brief);
 
 private:
+    friend bool comparesEqual(const Documentation &lhs,
+                              const  Documentation &rhs) noexcept
+    {
+        return lhs.m_format == rhs.m_format && lhs.m_detailed == rhs.m_detailed
+               && lhs.m_brief == rhs.m_brief;
+    }
+    Q_DECLARE_EQUALITY_COMPARABLE(Documentation)
+
     QString m_detailed;
     QString m_brief;
     Format m_format = Documentation::Native;
 };
 
-inline bool operator==(const Documentation &d1, const Documentation &d2)
-{ return d1.equals(d2); }
-inline bool operator!=(const Documentation &d1, const Documentation &d2)
-{ return !d1.equals(d2); }
-
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug debug, const Documentation &);
 #endif
diff --git a/sources/shiboken6/ApiExtractor/dotview.cpp b/sources/shiboken6/ApiExtractor/dotview.cpp
index da94f5e7f..0bd192257 100644
--- a/sources/shiboken6/ApiExtractor/dotview.cpp
+++ b/sources/shiboken6/ApiExtractor/dotview.cpp
@@ -13,7 +13,7 @@ using namespace Qt::StringLiterals;
 
 bool showDotGraph(const QString &name, const QString &graph)
 {
-    const QString imageType = u"jpg"_s;
+    constexpr auto imageType = "jpg"_L1;
 
     // Write out the graph to a temporary file
     QTemporaryFile dotFile(QDir::tempPath() + u'/' + name + u"_XXXXXX.dot"_s);
@@ -43,9 +43,9 @@ bool showDotGraph(const QString &name, const QString &graph)
     // Launch image. Should use QDesktopServices::openUrl(),
     // but we don't link against QtGui
 #ifdef Q_OS_UNIX
-    const QString imageViewer = u"gwenview"_s;
+    constexpr auto imageViewer = "gwenview"_L1;
 #else
-    const QString imageViewer = u"mspaint"_s;
+    constexpr auto imageViewer = "mspaint"_L1;
 #endif
     if (!QProcess::startDetached(imageViewer, {imageFile})) {
         qWarning("Failed to launch viewer: %s", qPrintable(imageViewer));
diff --git a/sources/shiboken6/ApiExtractor/doxygenparser.cpp b/sources/shiboken6/ApiExtractor/doxygenparser.cpp
index 8f608cbc8..da790015f 100644
--- a/sources/shiboken6/ApiExtractor/doxygenparser.cpp
+++ b/sources/shiboken6/ApiExtractor/doxygenparser.cpp
@@ -41,7 +41,7 @@ Documentation DoxygenParser::retrieveModuleDocumentation()
         return retrieveModuleDocumentation(packageName());
 }
 
-void DoxygenParser::fillDocumentation(AbstractMetaClass *metaClass)
+void DoxygenParser::fillDocumentation(const AbstractMetaClassPtr &metaClass)
 {
     if (!metaClass)
         return;
@@ -54,13 +54,12 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass *metaClass)
     doxyFileSuffix += metaClass->name();
     doxyFileSuffix += u".xml"_s;
 
-    const char* prefixes[] = { "class", "struct", "namespace" };
+    static constexpr QLatin1StringView prefixes[] = { "class"_L1, "struct"_L1, "namespace"_L1 };
     bool isProperty = false;
 
     QString doxyFilePath;
-    for (const char *prefix : prefixes) {
-        doxyFilePath = documentationDataDirectory() + u'/'
-                       + QLatin1StringView(prefix) + doxyFileSuffix;
+    for (const auto &prefix : prefixes) {
+        doxyFilePath = documentationDataDirectory() + u'/' + prefix + doxyFileSuffix;
         if (QFile::exists(doxyFilePath))
             break;
         doxyFilePath.clear();
@@ -76,12 +75,12 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass *metaClass)
 
     QString errorMessage;
     XQueryPtr xquery = XQuery::create(doxyFilePath, &errorMessage);
-    if (xquery.isNull()) {
+    if (!xquery) {
         qCWarning(lcShibokenDoc, "%s", qPrintable(errorMessage));
         return;
     }
 
-    static const QList<QPair<Documentation::Type, QString>> docTags = {
+    static const QList<std::pair<Documentation::Type, QString>> docTags = {
         { Documentation::Brief,  u"briefdescription"_s },
         { Documentation::Detailed,  u"detaileddescription"_s }
     };
@@ -119,7 +118,7 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass *metaClass)
                      + func->originalName() + u"\"]"_s;
 
             if (func->arguments().isEmpty()) {
-                QString args = func->isConstant() ? u"() const "_s : u"()"_s;
+                QString args = func->isConstant() ? u"() const"_s : u"()"_s;
                 query += u"/../argsstring[text()=\""_s + args + u"\"]"_s;
             } else {
                 int i = 1;
@@ -151,16 +150,16 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass *metaClass)
             }
 
             QString doc = getDocumentation(xquery, funcQuery,
-                                           DocParser::getDocModifications(metaClass, func));
+                                           DocParser::getXpathDocModifications(func, metaClass));
             if (doc.isEmpty()) {
                 qCWarning(lcShibokenDoc, "%s",
-                          qPrintable(msgCannotFindDocumentation(doxyFilePath, func.data(),
+                          qPrintable(msgCannotFindDocumentation(doxyFilePath, func.get(),
                                                                 funcQuery)));
             } else {
                 funcDoc.setValue(doc, tag.first);
             }
         }
-        qSharedPointerConstCast<AbstractMetaFunction>(func)->setDocumentation(funcDoc);
+        std::const_pointer_cast<AbstractMetaFunction>(func)->setDocumentation(funcDoc);
         isProperty = false;
     }
 
@@ -207,12 +206,12 @@ Documentation DoxygenParser::retrieveModuleDocumentation(const QString& name){
         qCWarning(lcShibokenDoc).noquote().nospace()
             << "Can't find doxygen XML file for module " << name << ", tried: "
             << QDir::toNativeSeparators(sourceFile);
-        return Documentation();
+        return {};
     }
 
     QString errorMessage;
     XQueryPtr xquery = XQuery::create(sourceFile, &errorMessage);
-    if (xquery.isNull()) {
+    if (!xquery) {
         qCWarning(lcShibokenDoc, "%s", qPrintable(errorMessage));
         return {};
     }
diff --git a/sources/shiboken6/ApiExtractor/doxygenparser.h b/sources/shiboken6/ApiExtractor/doxygenparser.h
index ea1883d12..4f6a9e53c 100644
--- a/sources/shiboken6/ApiExtractor/doxygenparser.h
+++ b/sources/shiboken6/ApiExtractor/doxygenparser.h
@@ -10,7 +10,7 @@ class DoxygenParser : public DocParser
 {
 public:
     DoxygenParser() = default;
-    void fillDocumentation(AbstractMetaClass *metaClass) override;
+    void fillDocumentation(const AbstractMetaClassPtr &metaClass) override;
     Documentation retrieveModuleDocumentation() override;
     Documentation retrieveModuleDocumentation(const QString& name) override;
 };
diff --git a/sources/shiboken6/ApiExtractor/enclosingclassmixin.cpp b/sources/shiboken6/ApiExtractor/enclosingclassmixin.cpp
index f2d5074b7..2421ae527 100644
--- a/sources/shiboken6/ApiExtractor/enclosingclassmixin.cpp
+++ b/sources/shiboken6/ApiExtractor/enclosingclassmixin.cpp
@@ -5,9 +5,9 @@
 #include "abstractmetalang.h"
 #include "namespacetypeentry.h"
 
-const AbstractMetaClass *EnclosingClassMixin::targetLangEnclosingClass() const
+AbstractMetaClassCPtr EnclosingClassMixin::targetLangEnclosingClass() const
 {
-    auto result = m_enclosingClass;
+    auto result = m_enclosingClass.lock();
     while (result && !NamespaceTypeEntry::isVisibleScope(result->typeEntry()))
         result = result->enclosingClass();
     return result;
diff --git a/sources/shiboken6/ApiExtractor/enclosingclassmixin.h b/sources/shiboken6/ApiExtractor/enclosingclassmixin.h
index 31aeb9285..8d735d5ec 100644
--- a/sources/shiboken6/ApiExtractor/enclosingclassmixin.h
+++ b/sources/shiboken6/ApiExtractor/enclosingclassmixin.h
@@ -4,16 +4,21 @@
 #ifndef ENCLOSINGCLASSMIXIN_H
 #define ENCLOSINGCLASSMIXIN_H
 
+#include "abstractmetalang_typedefs.h"
+
 class AbstractMetaClass;
 
 class EnclosingClassMixin {
 public:
-    const AbstractMetaClass *enclosingClass() const { return m_enclosingClass; }
-    void setEnclosingClass(const AbstractMetaClass *cls) { m_enclosingClass = cls; }
-    const AbstractMetaClass *targetLangEnclosingClass() const;
+
+    const AbstractMetaClassCPtr enclosingClass() const
+        { return m_enclosingClass.lock(); }
+    void setEnclosingClass(const AbstractMetaClassCPtr &cls)
+        { m_enclosingClass = cls; }
+    AbstractMetaClassCPtr targetLangEnclosingClass() const;
 
 private:
-     const AbstractMetaClass *m_enclosingClass = nullptr;
+    std::weak_ptr<const AbstractMetaClass> m_enclosingClass;
 };
 
 #endif // ENCLOSINGCLASSMIXIN_H
diff --git a/sources/shiboken6/ApiExtractor/enumtypeentry.h b/sources/shiboken6/ApiExtractor/enumtypeentry.h
index 14bab50cf..3360d7db5 100644
--- a/sources/shiboken6/ApiExtractor/enumtypeentry.h
+++ b/sources/shiboken6/ApiExtractor/enumtypeentry.h
@@ -4,12 +4,13 @@
 #ifndef ENUMTYPEENTRY_H
 #define ENUMTYPEENTRY_H
 
-#include "typesystem.h"
+#include "configurabletypeentry.h"
 #include "typesystem_enums.h"
 
 class EnumTypeEntryPrivate;
 
-class EnumTypeEntry : public TypeEntry
+// EnumTypeEntry is configurable for global enums only
+class EnumTypeEntry : public ConfigurableTypeEntry
 {
 public:
     explicit EnumTypeEntry(const QString &entryName,
@@ -36,6 +37,9 @@ public:
     void addEnumValueRejection(const QString &name);
     QStringList enumValueRejections() const;
 
+    QString docFile() const;
+    void setDocFile(const QString &df);
+
     TypeEntry *clone() const override;
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &d) const override;
diff --git a/sources/shiboken6/ApiExtractor/fileout.cpp b/sources/shiboken6/ApiExtractor/fileout.cpp
index da81f5a1b..6f9ec4d8a 100644
--- a/sources/shiboken6/ApiExtractor/fileout.cpp
+++ b/sources/shiboken6/ApiExtractor/fileout.cpp
@@ -175,7 +175,7 @@ FileOut::State FileOut::done()
     if (!FileOut::m_dryRun) {
         QDir dir(info.absolutePath());
         if (!dir.mkpath(dir.absolutePath())) {
-            const QString message = QStringLiteral("Unable to create directory '%1'")
+            const QString message = QString::fromLatin1("Unable to create directory '%1'")
                                         .arg(QDir::toNativeSeparators(dir.absolutePath()));
             throw Exception(message);
         }
diff --git a/sources/shiboken6/ApiExtractor/fileout.h b/sources/shiboken6/ApiExtractor/fileout.h
index d3f1b7b1f..b11ad1e20 100644
--- a/sources/shiboken6/ApiExtractor/fileout.h
+++ b/sources/shiboken6/ApiExtractor/fileout.h
@@ -14,7 +14,7 @@ class FileOut
 {
     QByteArray m_buffer;
 public:
-    Q_DISABLE_COPY(FileOut)
+    Q_DISABLE_COPY_MOVE(FileOut)
 
     enum State { Unchanged, Success };
 
diff --git a/sources/shiboken6/ApiExtractor/flagstypeentry.h b/sources/shiboken6/ApiExtractor/flagstypeentry.h
index b784b64e6..6eddcd12b 100644
--- a/sources/shiboken6/ApiExtractor/flagstypeentry.h
+++ b/sources/shiboken6/ApiExtractor/flagstypeentry.h
@@ -9,6 +9,7 @@
 class EnumTypeEntry;
 class FlagsTypeEntryPrivate;
 
+// FlagsTypeEntry is configurable for global flags only
 class FlagsTypeEntry : public TypeEntry
 {
 public:
diff --git a/sources/shiboken6/ApiExtractor/functiontypeentry.h b/sources/shiboken6/ApiExtractor/functiontypeentry.h
index 0901ff017..53aa1fad6 100644
--- a/sources/shiboken6/ApiExtractor/functiontypeentry.h
+++ b/sources/shiboken6/ApiExtractor/functiontypeentry.h
@@ -5,7 +5,6 @@
 #define FUNCTIONTYPEENTRY_H
 
 #include "typesystem.h"
-#include "typesystem_enums.h"
 
 class FunctionTypeEntryPrivate;
 
@@ -20,8 +19,8 @@ public:
     bool hasSignature(const QString& signature) const;
     void addSignature(const QString& signature);
 
-    TypeSystem::SnakeCase snakeCase() const;
-    void setSnakeCase(TypeSystem::SnakeCase sc);
+    QString docFile() const;
+    void setDocFile(const QString &df);
 
     TypeEntry *clone() const override;
 
diff --git a/sources/shiboken6/ApiExtractor/icecc.cmake b/sources/shiboken6/ApiExtractor/icecc.cmake
index b2bf071aa..fa8d3b7cf 100644
--- a/sources/shiboken6/ApiExtractor/icecc.cmake
+++ b/sources/shiboken6/ApiExtractor/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/shiboken6/ApiExtractor/include.cpp b/sources/shiboken6/ApiExtractor/include.cpp
index d2d577817..aee6b7337 100644
--- a/sources/shiboken6/ApiExtractor/include.cpp
+++ b/sources/shiboken6/ApiExtractor/include.cpp
@@ -24,18 +24,15 @@ QString Include::toString() const
     return u"import "_s + m_name + u';';
 }
 
-int Include::compare(const Include &rhs) const
+Qt::strong_ordering compareThreeWay(const Include &lhs, const Include &rhs) noexcept
 {
-    if (m_type < rhs.m_type)
-        return -1;
-    if (m_type > rhs.m_type)
-        return 1;
-    return m_name.compare(rhs.m_name);
-}
-
-size_t qHash(const Include& inc)
-{
-    return qHash(inc.m_name);
+    if (lhs.m_type < rhs.m_type)
+        return Qt::strong_ordering::less;
+    if (lhs.m_type > rhs.m_type)
+        return Qt::strong_ordering::greater;
+    if (auto c = lhs.m_name.compare(rhs.m_name))
+        return c < 0 ? Qt::strong_ordering::less : Qt::strong_ordering::greater;
+    return Qt::strong_ordering::equal;
 }
 
 QTextStream& operator<<(QTextStream& out, const Include& g)
diff --git a/sources/shiboken6/ApiExtractor/include.h b/sources/shiboken6/ApiExtractor/include.h
index 7fd7d3b36..875a941f9 100644
--- a/sources/shiboken6/ApiExtractor/include.h
+++ b/sources/shiboken6/ApiExtractor/include.h
@@ -4,6 +4,8 @@
 #ifndef INCLUDE_H
 #define INCLUDE_H
 
+#include <QtCore/QtCompare>
+#include <QtCore/QHashFunctions>
 #include <QtCore/QString>
 #include <QtCore/QList>
 
@@ -42,45 +44,24 @@ public:
 
     QString toString() const;
 
-    friend size_t qHash(const Include &);
     int compare(const Include &rhs) const;
 
-    private:
-        IncludeType m_type = IncludePath;
-        QString m_name;
-};
-
-size_t qHash(const Include& inc);
-
-inline bool operator<(const Include &lhs, const Include &rhs)
-{
-    return lhs.compare(rhs) < 0;
-}
-
-inline bool operator<=(const Include &lhs, const Include &rhs)
-{
-    return lhs.compare(rhs) <= 0;
-}
-
-inline bool operator==(const Include &lhs, const Include &rhs)
-{
-    return lhs.compare(rhs) == 0;
-}
-
-inline bool operator!=(const Include &lhs, const Include &rhs)
-{
-    return lhs.compare(rhs) != 0;
-}
-
-inline bool operator>=(const Include &lhs, const Include &rhs)
-{
-    return lhs.compare(rhs) >= 0;
-}
+private:
+    friend size_t qHash(Include &inc, size_t seed = 0) noexcept
+    {
+        return qHashMulti(seed, inc.m_type, inc.m_name);
+    }
+    friend bool comparesEqual(const Include &lhs, const Include  &rhs) noexcept
+    {
+        return lhs.m_type == rhs.m_type && lhs.m_name == rhs.m_name;
+    }
+    friend Qt::strong_ordering compareThreeWay(const Include &lhs,
+                                               const Include &rhs) noexcept;
+    Q_DECLARE_STRONGLY_ORDERED(Include)
 
-inline bool operator>(const Include &lhs, const Include &rhs)
-{
-    return lhs.compare(rhs) > 0;
-}
+    IncludeType m_type = IncludePath;
+    QString m_name;
+};
 
 QTextStream& operator<<(QTextStream& out, const Include& include);
 TextStream& operator<<(TextStream& out, const Include& include);
diff --git a/sources/shiboken6/ApiExtractor/messages.cpp b/sources/shiboken6/ApiExtractor/messages.cpp
index 247bb7db0..170595660 100644
--- a/sources/shiboken6/ApiExtractor/messages.cpp
+++ b/sources/shiboken6/ApiExtractor/messages.cpp
@@ -16,7 +16,6 @@
 
 #include "qtcompat.h"
 
-#include <QtCore/QCoreApplication>
 #include <QtCore/QDebug>
 #include <QtCore/QDir>
 #include <QtCore/QFile>
@@ -25,11 +24,25 @@
 
 using namespace Qt::StringLiterals;
 
-static inline QString colonColon() { return QStringLiteral("::"); }
-
 // abstractmetabuilder.cpp
 
-QString msgNoFunctionForModification(const AbstractMetaClass *klass,
+static QTextStream &operator<<(QTextStream &s, Access a)
+{
+    switch (a) {
+    case Access::Public:
+        s << "public";
+        break;
+    case Access::Protected:
+        s << "protected";
+        break;
+    case Access::Private:
+        s << "private";
+        break;
+    }
+    return s;
+}
+
+QString msgNoFunctionForModification(const AbstractMetaClassCPtr &klass,
                                      const QString &signature,
                                      const QString &originalSignature,
                                      const QStringList &possibleSignatures,
@@ -79,7 +92,7 @@ QString msgTypeModificationFailed(const QString &type, int n,
         str << "type of argument " << n;
 
     str << " of ";
-    if (auto *c = func->ownerClass())
+    if (auto c = func->ownerClass())
         str << c->name() << "::";
     str << func->signature() << " to \"" << type << "\": " << why;
     return result;
@@ -113,7 +126,7 @@ QString msgArgumentRemovalFailed(const AbstractMetaFunction *func, int n,
     QString result;
     QTextStream str(&result);
     str << "Unable to remove argument " << n << " of ";
-    if (auto *c = func->ownerClass())
+    if (auto c = func->ownerClass())
         str << c->name() << "::";
     str << func->signature() << ":  " << why;
     return result;
@@ -126,7 +139,7 @@ static void msgFormatEnumType(Stream &str,
 {
     switch (enumItem->enumKind()) {
     case CEnum:
-        str << "Enum '" << enumItem->qualifiedName().join(colonColon()) << '\'';
+        str << "Enum '" << enumItem->qualifiedName().join(u"::"_s) << '\'';
         break;
     case AnonymousEnum: {
         const EnumeratorList &values = enumItem->enumerators();
@@ -149,7 +162,7 @@ static void msgFormatEnumType(Stream &str,
     }
         break;
     case EnumClass:
-        str << "Scoped enum '" << enumItem->qualifiedName().join(colonColon()) << '\'';
+        str << "Scoped enum '" << enumItem->qualifiedName().join(u"::"_s) << '\'';
         break;
     }
     if (!className.isEmpty())
@@ -157,7 +170,7 @@ static void msgFormatEnumType(Stream &str,
 }
 
 static void formatAddedFuncError(const QString &addedFuncName,
-                                 const AbstractMetaClass *context,
+                                 const AbstractMetaClassCPtr &context,
                                  QTextStream &str)
 {
     if (context) {
@@ -173,12 +186,12 @@ static void formatAddedFuncError(const QString &addedFuncName,
 QString msgAddedFunctionInvalidArgType(const QString &addedFuncName,
                                        const QStringList &typeName,
                                        int pos, const QString &why,
-                                       const AbstractMetaClass *context)
+                                       const AbstractMetaClassCPtr &context)
 {
     QString result;
     QTextStream str(&result);
     formatAddedFuncError(addedFuncName, context, str);
-    str << "Unable to translate type \"" << typeName.join(colonColon())
+    str << "Unable to translate type \"" << typeName.join(u"::"_s)
         << "\" of argument " << pos << " of added function \""
         << addedFuncName << "\": " << why;
     return result;
@@ -186,18 +199,18 @@ QString msgAddedFunctionInvalidArgType(const QString &addedFuncName,
 
 QString msgAddedFunctionInvalidReturnType(const QString &addedFuncName,
                                           const QStringList &typeName, const QString &why,
-                                          const AbstractMetaClass *context)
+                                          const AbstractMetaClassCPtr &context)
 {
     QString result;
     QTextStream str(&result);
     formatAddedFuncError(addedFuncName, context, str);
-    str << "Unable to translate return type \"" << typeName.join(colonColon())
+    str << "Unable to translate return type \"" << typeName.join(u"::"_s)
         << "\" of added function \"" << addedFuncName << "\": "
         << why;
     return result;
 }
 
-QString msgUnnamedArgumentDefaultExpression(const AbstractMetaClass *context,
+QString msgUnnamedArgumentDefaultExpression(const AbstractMetaClassCPtr &context,
                                             int n, const QString &className,
                                             const AbstractMetaFunction *f)
 {
@@ -227,7 +240,8 @@ QString msgNoEnumTypeEntry(const EnumModelItem &enumItem,
     QTextStream str(&result);
     str << enumItem->sourceLocation();
     msgFormatEnumType(str, enumItem, className);
-    str << " does not have a type entry";
+    str << " does not have a type entry (type systems: "
+        << TypeDatabase::instance()->loadedTypeSystemNames() << ')';
     return result;
 }
 
@@ -251,7 +265,8 @@ QString msgNamespaceNoTypeEntry(const NamespaceModelItem &item,
     QString result;
     QTextStream str(&result);
     str << item->sourceLocation() << "namespace '" << fullName
-        << "' does not have a type entry";
+        << "' does not have a type entry (type systems: "
+        << TypeDatabase::instance()->loadedTypeSystemNames() << ')';
     return result;
 }
 
@@ -302,11 +317,13 @@ QString msgSkippingFunction(const FunctionModelItem &functionItem,
 {
     QString result;
     QTextStream str(&result);
-    str << functionItem->sourceLocation() << "skipping ";
-    if (functionItem->isAbstract())
+    str << functionItem->sourceLocation() << "skipping "
+        << functionItem->accessPolicy() << ' ';
+    const bool isAbstract = functionItem->attributes().testFlag(FunctionAttribute::Abstract);
+    if (isAbstract)
         str << "abstract ";
     str << "function '" << signature << "', " << why;
-    if (functionItem->isAbstract()) {
+    if (isAbstract) {
         str << "\nThis will lead to compilation errors due to not "
                "being able to instantiate the wrapper.";
     }
@@ -324,7 +341,7 @@ QString msgShadowingFunction(const AbstractMetaFunction *f1,
     return result;
 }
 
-QString msgSignalOverloaded(const AbstractMetaClass *c,
+QString msgSignalOverloaded(const AbstractMetaClassCPtr &c,
                             const AbstractMetaFunction *f)
 {
     QString result;
@@ -339,8 +356,9 @@ QString msgSkippingField(const VariableModelItem &field, const QString &classNam
 {
     QString result;
     QTextStream str(&result);
-    str << field->sourceLocation() << "skipping field '" << className
-        << "::" << field->name() << "' with unmatched type '" << type << '\'';
+    str << field->sourceLocation() << "skipping " << field->accessPolicy()
+        << " field '" << className << "::" << field->name()
+        << "' with unmatched type '" << type << '\'';
     return result;
 }
 
@@ -351,8 +369,14 @@ QString msgTypeNotDefined(const TypeEntryCPtr &entry)
 {
     QString result;
     QTextStream str(&result);
+    const bool hasConfigCondition = entry->isComplex()
+        && std::static_pointer_cast<const ConfigurableTypeEntry>(entry)->hasConfigCondition();
     str << entry->sourceLocation() << "type '" <<entry->qualifiedCppName()
-        << "' is specified in typesystem, but not defined. " << msgCompilationError;
+        << "' is specified in typesystem, but not defined";
+    if (hasConfigCondition)
+        str << " (disabled by configuration?).";
+    else
+        str << ". " << msgCompilationError;
     return result;
 }
 
@@ -372,14 +396,15 @@ QString msgGlobalFunctionNotDefined(const FunctionTypeEntryCPtr &fte,
 
 QString msgStrippingArgument(const FunctionModelItem &f, int i,
                              const QString &originalSignature,
-                             const ArgumentModelItem &arg)
+                             const ArgumentModelItem &arg,
+                             const QString &reason)
 {
     QString result;
     QTextStream str(&result);
     str << f->sourceLocation() << "Stripping argument #" << (i + 1) << " of "
         << originalSignature << " due to unmatched type \""
         << arg->type().toString() << "\" with default expression \""
-        << arg->defaultValueExpression() << "\".";
+        << arg->defaultValueExpression() << "\": " << reason;
     return result;
 }
 
@@ -392,7 +417,7 @@ QString msgEnumNotDefined(const EnumTypeEntryCPtr &t)
     return result;
 }
 
-QString msgUnknownBase(const AbstractMetaClass *metaClass,
+QString msgUnknownBase(const AbstractMetaClassCPtr &metaClass,
                        const QString &baseClassName)
 {
     QString result;
@@ -402,7 +427,7 @@ QString msgUnknownBase(const AbstractMetaClass *metaClass,
     return result;
 }
 
-QString msgBaseNotInTypeSystem(const AbstractMetaClass *metaClass,
+QString msgBaseNotInTypeSystem(const AbstractMetaClassCPtr &metaClass,
                                const QString &baseClassName)
 {
     QString result;
@@ -456,6 +481,21 @@ QString msgCannotFindTypeEntryForSmartPointer(const QString &t, const QString &s
         + u"\" for instantiation of \""_s +smartPointerType + u"\"."_s;
 }
 
+QString msgInheritTemplateIssue(const AbstractMetaClassPtr &subclass,
+                                const TypeInfo &info,
+                                const QString &what)
+{
+    return "While inheriting template "_L1 + subclass->name()
+           + " from "_L1 + info.toString() + ": "_L1 + what;
+}
+
+QString msgIgnoringTemplateParameter(const QString &typeName,
+                                     const char *why)
+{
+    return "Ignoring template parameter "_L1 + typeName +
+           ": "_L1 + QLatin1StringView(why);
+}
+
 QString msgInvalidSmartPointerType(const TypeInfo &i)
 {
     return u"Invalid smart pointer type \""_s +i.toString() + u"\"."_s;
@@ -511,7 +551,7 @@ QString msgPropertyExists(const QString &className, const QString &name)
            + name + u"\" (defined by Q_PROPERTY)."_s;
 }
 
-QString msgFunctionVisibilityModified(const AbstractMetaClass *c,
+QString msgFunctionVisibilityModified(const AbstractMetaClassCPtr &c,
                                       const AbstractMetaFunction *f)
 {
     QString result;
@@ -521,7 +561,7 @@ QString msgFunctionVisibilityModified(const AbstractMetaClass *c,
     return result;
 }
 
-QString msgUsingMemberClassNotFound(const AbstractMetaClass *c,
+QString msgUsingMemberClassNotFound(const AbstractMetaClassCPtr &c,
                                     const QString &baseClassName,
                                     const QString &memberName)
 {
@@ -587,23 +627,25 @@ QString msgFallbackForDocumentation(const QString &fileName,
 }
 
 QString msgCannotFindDocumentation(const QString &fileName,
-                                   const AbstractMetaClass *metaClass,
+                                   const AbstractMetaClassCPtr &metaClass,
                                    const AbstractMetaEnum &e,
                                    const QString &query)
 {
-    return msgCannotFindDocumentation(fileName, "enum",
-                                      metaClass->name() + u"::"_s + e.name(),
-                                      query);
+    QString name = e.name();
+    if (metaClass != nullptr)
+        name.prepend(metaClass->name() + "::"_L1);
+    return msgCannotFindDocumentation(fileName, "enum", name, query);
 }
 
 QString msgCannotFindDocumentation(const QString &fileName,
-                                   const AbstractMetaClass *metaClass,
+                                   const AbstractMetaClassCPtr &metaClass,
                                    const AbstractMetaField &f,
                                    const QString &query)
 {
-    return msgCannotFindDocumentation(fileName, "field",
-                                      metaClass->name() + u"::"_s + f.name(),
-                                      query);
+    QString name = f.name();
+    if (metaClass != nullptr)
+        name.prepend(metaClass->name() + "::"_L1);
+    return msgCannotFindDocumentation(fileName, "field", name, query);
 }
 
 QString msgXpathDocModificationError(const DocModificationList& mods,
@@ -631,13 +673,13 @@ QString msgXpathDocModificationError(const DocModificationList& mods,
 
 QString msgCannotOpenForReading(const QFile &f)
 {
-    return QStringLiteral("Failed to open file '%1' for reading: %2")
+    return QString::fromLatin1("Failed to open file '%1' for reading: %2")
            .arg(QDir::toNativeSeparators(f.fileName()), f.errorString());
 }
 
 QString msgCannotOpenForWriting(const QFile &f)
 {
-    return QStringLiteral("Failed to open file '%1' for writing: %2")
+    return QString::fromLatin1("Failed to open file '%1' for writing: %2")
            .arg(QDir::toNativeSeparators(f.fileName()), f.errorString());
 }
 
@@ -659,23 +701,6 @@ QString msgCannotUseEnumAsInt(const QString &name)
            "Compilation errors may occur when used as a function argument."_s;
 }
 
-QString msgConversionTypesDiffer(const QString &varType, const QString &conversionType)
-{
-    QString result;
-    QTextStream str(&result);
-    str << "Types of receiver variable ('" << varType
-         << "') and %%CONVERTTOCPP type system variable ('" << conversionType
-         << "') differ";
-    QString strippedVarType = varType;
-    QString strippedConversionType = conversionType;
-    TypeInfo::stripQualifiers(&strippedVarType);
-    TypeInfo::stripQualifiers(&strippedConversionType);
-    if (strippedVarType == strippedConversionType)
-        str << " in qualifiers. Please make sure the type is a distinct token";
-    str << '.';
-    return result;
-}
-
 QString msgCannotFindSmartPointerGetter(const SmartPointerTypeEntryCPtr &te)
 {
      return u"Getter \""_s + te->getter() +  u"()\" of smart pointer \""_s
@@ -688,7 +713,7 @@ QString msgCannotFindSmartPointerMethod(const SmartPointerTypeEntryCPtr &te, con
         + te->name() + u"\" not found."_s;
 }
 
-QString msgMethodNotFound(const AbstractMetaClass *klass, const QString &name)
+QString msgMethodNotFound(const AbstractMetaClassCPtr &klass, const QString &name)
 {
      return u"Method \""_s + name + u"\" not found in class "_s
             + klass->name() + u'.';
@@ -696,18 +721,12 @@ QString msgMethodNotFound(const AbstractMetaClass *klass, const QString &name)
 
 // main.cpp
 
-QString msgLeftOverArguments(const QVariantMap &remainingArgs)
+QString msgLeftOverArguments(const QString &remainingArgs, const QStringList &argV)
 {
     QString message;
     QTextStream str(&message);
-    str << "shiboken: Called with wrong arguments:";
-    for (auto it = remainingArgs.cbegin(), end = remainingArgs.cend(); it != end; ++it) {
-        str << ' ' << it.key();
-        const QString value = it.value().toString();
-        if (!value.isEmpty())
-            str << ' ' << value;
-    }
-    str << "\nCommand line: " << QCoreApplication::arguments().join(u' ');
+    str << "shiboken: Unprocessed arguments: " << remainingArgs
+        << "\nCommand line: " << argV.join(u' ');
     return message;
 }
 
@@ -734,7 +753,7 @@ QString msgCyclicDependency(const QString &funcName, const QString &graphName,
             if (i)
                 str << ", \"";
             str << involvedConversions.at(i)->signature() << '"';
-            if (const AbstractMetaClass *c = involvedConversions.at(i)->implementingClass())
+            if (const auto c = involvedConversions.at(i)->implementingClass())
                 str << '(' << c->name() << ')';
         }
     }
@@ -763,7 +782,7 @@ QString msgUnknownOperator(const AbstractMetaFunction *func)
 {
     QString result = u"Unknown operator: \""_s + func->originalName()
                      + u'"';
-    if (const AbstractMetaClass *c = func->implementingClass())
+    if (const auto c = func->implementingClass())
         result += u" in class: "_s + c->name();
     return result;
 }
@@ -774,7 +793,7 @@ QString msgWrongIndex(const char *varName, const QString &capture,
     QString result;
     QTextStream str(&result);
     str << "Wrong index for " << varName << " variable (" << capture << ") on ";
-    if (const AbstractMetaClass *c = func->implementingClass())
+    if (const auto c = func->implementingClass())
         str << c->name() << "::";
     str << func->signature();
     return  result;
@@ -816,17 +835,17 @@ QString msgRejectReason(const TypeRejection &r, const QString &needle)
     QTextStream str(&result);
     switch (r.matchType) {
     case TypeRejection::ExcludeClass:
-        str << " matches class exclusion \"" << r.className.pattern() << '"';
+        str << "matches class exclusion \"" << r.className.pattern() << '"';
         break;
     case TypeRejection::Function:
     case TypeRejection::Field:
     case TypeRejection::Enum:
-        str << " matches class \"" << r.className.pattern() << "\" and \""
+        str << "matches class \"" << r.className.pattern() << "\" and \""
             << r.pattern.pattern() << '"';
         break;
     case TypeRejection::ArgumentType:
     case TypeRejection::ReturnType:
-        str << " matches class \"" << r.className.pattern() << "\" and \""
+        str << "matches class \"" << r.className.pattern() << "\" and \""
             << needle << "\" matches \"" << r.pattern.pattern() << '"';
         break;
     }
@@ -879,6 +898,21 @@ QString msgCannotFindSnippet(const QString &file, const QString &snippetLabel)
     return result;
 }
 
+QString msgSnippetError(const QString &context, const char *what)
+{
+    return "Error processing code snippet of "_L1 + context
+           + ": "_L1 + QString::fromUtf8(what);
+}
+
+QString msgUnableToResolveTypedef(const QString &sourceType, const QString &sourceName)
+{
+    QString result;
+    QTextStream(&result) << "Unable to resolve typedef \"" << sourceType
+        << "\": Could not find a value, container, object or smart pointer type named \""
+        << sourceName << "\".";
+    return result;
+}
+
 // cppgenerator.cpp
 
 QString msgPureVirtualFunctionRemoved(const AbstractMetaFunction *f)
@@ -950,3 +984,21 @@ QString msgUnknownArrayPointerConversion(const QString &s)
     return u"Warning: Falling back to pointer conversion for unknown array type \""_s
         + s + u"\""_s;
 }
+
+QString msgMissingProjectFileMarker(const QString &name, const QByteArray &startMarker)
+{
+    return u"First line of project file \""_s + QDir::toNativeSeparators(name)
+        + u"\" must be the string \""_s + QString::fromLatin1(startMarker) + u"\"."_s;
+}
+
+QString msgInvalidLanguageLevel(const QString &l)
+{
+    return u"Invalid argument for language level: \""_s + l + u"\"."_s;
+}
+
+QString msgCannotFindImage(const QString &href, const QString &context,
+                           const QString &candidate)
+{
+    return "Cannot resolve image "_L1 + href + " for "_L1 + context
+           + " (tried "_L1 + QDir::toNativeSeparators(candidate) + ")."_L1;
+}
diff --git a/sources/shiboken6/ApiExtractor/messages.h b/sources/shiboken6/ApiExtractor/messages.h
index 17255f717..5216b26a7 100644
--- a/sources/shiboken6/ApiExtractor/messages.h
+++ b/sources/shiboken6/ApiExtractor/messages.h
@@ -25,19 +25,19 @@ QT_FORWARD_DECLARE_CLASS(QXmlStreamReader)
 QString msgAddedFunctionInvalidArgType(const QString &addedFuncName,
                                        const QStringList &typeName,
                                        int pos, const QString &why,
-                                       const AbstractMetaClass *context = nullptr);
+                                       const AbstractMetaClassCPtr &context = {});
 
 QString msgAddedFunctionInvalidReturnType(const QString &addedFuncName,
                                           const QStringList &typeName, const QString &why,
-                                          const AbstractMetaClass *context = nullptr);
+                                          const AbstractMetaClassCPtr &context = {});
 
-QString msgUnnamedArgumentDefaultExpression(const AbstractMetaClass *context,
+QString msgUnnamedArgumentDefaultExpression(const AbstractMetaClassCPtr &context,
                                             int n, const QString &className,
                                             const AbstractMetaFunction *f);
 
 QString msgArgumentIndexOutOfRange(const AbstractMetaFunction *func, int index);
 
-QString msgNoFunctionForModification(const AbstractMetaClass *klass,
+QString msgNoFunctionForModification(const AbstractMetaClassCPtr &klass,
                                      const QString &signature,
                                      const QString &originalSignature,
                                      const QStringList &possibleSignatures,
@@ -82,7 +82,7 @@ QString msgUnmatchedReturnType(const FunctionModelItem &functionItem,
 QString msgShadowingFunction(const AbstractMetaFunction *f1,
                              const AbstractMetaFunction *f2);
 
-QString msgSignalOverloaded(const AbstractMetaClass *c,
+QString msgSignalOverloaded(const AbstractMetaClassCPtr &c,
                             const AbstractMetaFunction *f);
 
 QString msgSkippingFunction(const FunctionModelItem &functionItem,
@@ -99,14 +99,15 @@ QString msgGlobalFunctionNotDefined(const FunctionTypeEntryCPtr &fte,
 
 QString msgStrippingArgument(const FunctionModelItem &f, int i,
                              const QString &originalSignature,
-                             const ArgumentModelItem &arg);
+                             const ArgumentModelItem &arg,
+                             const QString &reason);
 
 QString msgEnumNotDefined(const EnumTypeEntryCPtr &t);
 
-QString msgUnknownBase(const AbstractMetaClass *metaClass,
+QString msgUnknownBase(const AbstractMetaClassCPtr &metaClass,
                        const QString &baseClassName);
 
-QString msgBaseNotInTypeSystem(const AbstractMetaClass *metaClass,
+QString msgBaseNotInTypeSystem(const AbstractMetaClassCPtr &metaClass,
                                const QString &baseClassName);
 
 QString msgArrayModificationFailed(const FunctionModelItem &functionItem,
@@ -125,6 +126,10 @@ QString msgUnableToTranslateType(const TypeInfo &typeInfo,
 QString msgCannotFindTypeEntry(const QString &t);
 
 QString msgCannotFindTypeEntryForSmartPointer(const QString &t, const QString &smartPointerType);
+QString msgInheritTemplateIssue(const AbstractMetaClassPtr &subclass,
+                                const TypeInfo &info, const QString &what);
+QString msgIgnoringTemplateParameter(const QString &typeName,
+                                     const char *why);
 QString msgInvalidSmartPointerType(const TypeInfo &i);
 QString msgCannotFindSmartPointerInstantion(const TypeInfo &i);
 
@@ -140,10 +145,10 @@ QString msgPropertyTypeParsingFailed(const QString &name, const QString &typeNam
                                      const QString &why);
 QString msgPropertyExists(const QString &className, const QString &name);
 
-QString msgFunctionVisibilityModified(const AbstractMetaClass *c,
+QString msgFunctionVisibilityModified(const AbstractMetaClassCPtr &c,
                                       const AbstractMetaFunction *f);
 
-QString msgUsingMemberClassNotFound(const AbstractMetaClass *c,
+QString msgUsingMemberClassNotFound(const AbstractMetaClassCPtr &c,
                                     const QString &baseClassName,
                                     const QString &memberName);
 
@@ -164,12 +169,12 @@ QString msgFallbackForDocumentation(const QString &fileName,
                                     const QString &query = {});
 
 QString msgCannotFindDocumentation(const QString &fileName,
-                                   const AbstractMetaClass *metaClass,
+                                   const AbstractMetaClassCPtr &metaClass,
                                    const AbstractMetaEnum &e,
                                    const QString &query = {});
 
 QString msgCannotFindDocumentation(const QString &fileName,
-                                   const AbstractMetaClass *metaClass,
+                                   const AbstractMetaClassCPtr &metaClass,
                                    const AbstractMetaField &f,
                                    const QString &query);
 
@@ -184,15 +189,13 @@ QString msgWriteFailed(const QFile &f, qsizetype size);
 
 QString msgCannotUseEnumAsInt(const QString &name);
 
-QString msgConversionTypesDiffer(const QString &varType, const QString &conversionType);
-
 QString msgCannotFindSmartPointerGetter(const SmartPointerTypeEntryCPtr &);
 
 QString msgCannotFindSmartPointerMethod(const SmartPointerTypeEntryCPtr &te, const QString &m);
 
-QString msgMethodNotFound(const AbstractMetaClass *klass, const QString &name);
+QString msgMethodNotFound(const AbstractMetaClassCPtr &klass, const QString &name);
 
-QString msgLeftOverArguments(const QVariantMap &remainingArgs);
+QString msgLeftOverArguments(const QString &remainingArgs, const QStringList &argV);
 
 QString msgInvalidVersion(const QString &package, const QString &version);
 
@@ -210,6 +213,8 @@ QString msgIncorrectlyNestedName(const QString &name);
 QString msgCannotFindView(const QString &viewedName, const QString &name);
 
 QString msgCannotFindSnippet(const QString &file, const QString &snippetLabel);
+QString msgSnippetError(const QString &context, const char *what);
+QString msgUnableToResolveTypedef(const QString &sourceType, const QString &sourceName);
 
 QString msgCyclicDependency(const QString &funcName, const QString &graphName,
                             const AbstractMetaFunctionCList &cyclic,
@@ -252,4 +257,11 @@ QString msgMissingCustomConversion(const TypeEntryCPtr &t);
 
 QString msgUnknownArrayPointerConversion(const QString &s);
 
+QString msgMissingProjectFileMarker(const QString &name, const QByteArray &startMarker);
+
+QString msgInvalidLanguageLevel(const QString &l);
+
+QString msgCannotFindImage(const QString &href, const QString &context,
+                           const QString &candidate);
+
 #endif // MESSAGES_H
diff --git a/sources/shiboken6/ApiExtractor/modifications.cpp b/sources/shiboken6/ApiExtractor/modifications.cpp
index d42cfb460..d876e8035 100644
--- a/sources/shiboken6/ApiExtractor/modifications.cpp
+++ b/sources/shiboken6/ApiExtractor/modifications.cpp
@@ -14,20 +14,6 @@
 
 using namespace Qt::StringLiterals;
 
-// ---------------------- Modification
-QString FunctionModification::accessModifierString() const
-{
-    if (isPrivate())
-        return u"private"_s;
-    if (isProtected())
-        return u"protected"_s;
-    if (isPublic())
-        return u"public"_s;
-    if (isFriendly())
-        return u"friendly"_s;
-    return QString();
-}
-
 // ---------------------- FieldModification
 
 class FieldModificationData : public QSharedData
@@ -48,8 +34,8 @@ FieldModification::FieldModification() : d(new FieldModificationData)
 
 FieldModification::FieldModification(const FieldModification &) = default;
 FieldModification &FieldModification::operator=(const FieldModification &) = default;
-FieldModification::FieldModification(FieldModification &&) = default;
-FieldModification &FieldModification::operator=(FieldModification &&) = default;
+FieldModification::FieldModification(FieldModification &&) noexcept = default;
+FieldModification &FieldModification::operator=(FieldModification &&) noexcept = default;
 FieldModification::~FieldModification() = default;
 
 QString FieldModification::name() const
@@ -188,7 +174,7 @@ QDebug operator<<(QDebug d, const CodeSnip &s)
         if (i)
             d << ", ";
         d << '#' << i << ' ';
-        if (f.instance().isNull()) {
+        if (!f.instance()) {
             d << '"';
             const QString &code = f.code();
             const auto lines = QStringView{code}.split(u'\n');
@@ -241,8 +227,8 @@ ArgumentModification::ArgumentModification(int idx) : d(new ArgumentModification
 
 ArgumentModification::ArgumentModification(const ArgumentModification &) = default;
 ArgumentModification &ArgumentModification::operator=(const ArgumentModification &) = default;
-ArgumentModification::ArgumentModification(ArgumentModification &&) = default;
-ArgumentModification &ArgumentModification::operator=(ArgumentModification &&) = default;
+ArgumentModification::ArgumentModification(ArgumentModification &&) noexcept = default;
+ArgumentModification &ArgumentModification::operator=(ArgumentModification &&) noexcept = default;
 ArgumentModification::~ArgumentModification() = default;
 
 const QString &ArgumentModification::modifiedType() const
@@ -423,7 +409,6 @@ public:
     QString m_originalSignature;
     QRegularExpression m_signaturePattern;
     int m_overloadNumber = TypeSystem::OverloadNumberUnset;
-    bool m_thread = false;
     bool removed = false;
     TypeSystem::AllowThread m_allowThread = TypeSystem::AllowThread::Unspecified;
     TypeSystem::ExceptionHandling m_exceptionHandling = TypeSystem::ExceptionHandling::Unspecified;
@@ -436,8 +421,8 @@ FunctionModification::FunctionModification() : d(new FunctionModificationData)
 
 FunctionModification::FunctionModification(const FunctionModification &) = default;
 FunctionModification &FunctionModification::operator=(const FunctionModification &) = default;
-FunctionModification::FunctionModification(FunctionModification &&) = default;
-FunctionModification &FunctionModification::operator=(FunctionModification &&) = default;
+FunctionModification::FunctionModification(FunctionModification &&) noexcept = default;
+FunctionModification &FunctionModification::operator=(FunctionModification &&) noexcept = default;
 FunctionModification::~FunctionModification() = default;
 
 void FunctionModification::formatDebug(QDebug &debug) const
@@ -453,8 +438,6 @@ void FunctionModification::formatDebug(QDebug &debug) const
         debug << ", renamedToName=\"" << d->renamedToName << '"';
     if (d->m_allowThread != TypeSystem::AllowThread::Unspecified)
         debug << ", allowThread=" << int(d->m_allowThread);
-    if (d->m_thread)
-        debug << ", thread";
     if (d->m_exceptionHandling != TypeSystem::ExceptionHandling::Unspecified)
         debug << ", exceptionHandling=" << int(d->m_exceptionHandling);
     if (!d->m_snips.isEmpty())
@@ -557,17 +540,6 @@ void FunctionModification::setSnips(const CodeSnipList &snips)
 }
 
 // ---------------------- FunctionModification
-void FunctionModification::setIsThread(bool flag)
-{
-    if (d->m_thread != flag)
-        d->m_thread = flag;
-}
-
-bool FunctionModification::isThread() const
-{
-    return d->m_thread;
-}
-
 FunctionModification::AllowThread FunctionModification::allowThread() const
 {
     return d->m_allowThread;
diff --git a/sources/shiboken6/ApiExtractor/modifications.h b/sources/shiboken6/ApiExtractor/modifications.h
index 65ed81ff8..27a38f1aa 100644
--- a/sources/shiboken6/ApiExtractor/modifications.h
+++ b/sources/shiboken6/ApiExtractor/modifications.h
@@ -64,8 +64,8 @@ public:
     explicit ArgumentModification(int idx);
     ArgumentModification(const ArgumentModification &);
     ArgumentModification &operator=(const ArgumentModification &);
-    ArgumentModification(ArgumentModification &&);
-    ArgumentModification &operator=(ArgumentModification &&);
+    ArgumentModification(ArgumentModification &&) noexcept;
+    ArgumentModification &operator=(ArgumentModification &&) noexcept;
     ~ArgumentModification();
 
     // Reference count flags for this argument
@@ -134,15 +134,14 @@ public:
     FunctionModification();
     FunctionModification(const FunctionModification &);
     FunctionModification &operator=(const FunctionModification &);
-    FunctionModification(FunctionModification &&);
-    FunctionModification &operator=(FunctionModification &&);
+    FunctionModification(FunctionModification &&) noexcept;
+    FunctionModification &operator=(FunctionModification &&) noexcept;
     ~FunctionModification();
 
     enum ModifierFlag {
         Private =               0x0001,
         Protected =             0x0002,
-        Public =                0x0003,
-        Friendly =              0x0004,
+        Public =                0x0004,
         AccessModifierMask =    0x000f,
 
         Final =                 0x0010,
@@ -155,7 +154,8 @@ public:
         CodeInjection =         0x1000,
         Rename =                0x2000,
         Deprecated =            0x4000,
-        ReplaceExpression =     0x8000
+        Undeprecated =          0x8000,
+        ReplaceExpression =    0x10000
     };
 
     Q_DECLARE_FLAGS(Modifiers, ModifierFlag);
@@ -190,10 +190,6 @@ public:
     {
         return accessModifier() == Public;
     }
-    bool isFriendly() const
-    {
-        return accessModifier() == Friendly;
-    }
     bool isFinal() const
     {
         return modifiers().testFlag(Final);
@@ -202,7 +198,6 @@ public:
     {
         return modifiers().testFlag(NonFinal);
     }
-    QString accessModifierString() const;
 
     bool isDeprecated() const
     {
@@ -222,8 +217,6 @@ public:
     {
         return modifiers().testFlag(CodeInjection);
     }
-    void setIsThread(bool flag);
-    bool isThread() const;
 
     AllowThread allowThread() const;
     void setAllowThread(AllowThread allow);
@@ -278,8 +271,8 @@ public:
     FieldModification();
     FieldModification(const FieldModification &);
     FieldModification &operator=(const FieldModification &);
-    FieldModification(FieldModification &&);
-    FieldModification &operator=(FieldModification &&);
+    FieldModification(FieldModification &&) noexcept;
+    FieldModification &operator=(FieldModification &&) noexcept;
     ~FieldModification();
 
     QString name() const;
diff --git a/sources/shiboken6/ApiExtractor/modifications_typedefs.h b/sources/shiboken6/ApiExtractor/modifications_typedefs.h
index c827335ab..3b86c55d3 100644
--- a/sources/shiboken6/ApiExtractor/modifications_typedefs.h
+++ b/sources/shiboken6/ApiExtractor/modifications_typedefs.h
@@ -5,7 +5,8 @@
 #define MODIFICATIONS_TYPEDEFS_H
 
 #include <QtCore/QList>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
 
 class CodeSnip;
 class DocModification;
@@ -14,7 +15,7 @@ struct AddedFunction;
 class FieldModification;
 class FunctionModification;
 
-using AddedFunctionPtr = QSharedPointer<AddedFunction>;
+using AddedFunctionPtr = std::shared_ptr<AddedFunction>;
 using AddedFunctionList = QList<AddedFunctionPtr>;
 using CodeSnipList = QList<CodeSnip>;
 using DocModificationList = QList<DocModification>;
diff --git a/sources/shiboken6/ApiExtractor/optionsparser.cpp b/sources/shiboken6/ApiExtractor/optionsparser.cpp
new file mode 100644
index 000000000..f2e64c7e4
--- /dev/null
+++ b/sources/shiboken6/ApiExtractor/optionsparser.cpp
@@ -0,0 +1,232 @@
+// 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 "optionsparser.h"
+#include "messages.h"
+#include "exception.h"
+
+#include <QtCore/QDir>
+#include <QtCore/QTextStream>
+
+using namespace Qt::StringLiterals;
+
+template <class Stream> void formatBoolOption(Stream &s, const BoolOption &bo)
+{
+    switch (bo.source) {
+    case OptionSource::CommandLine:
+        s << "--";
+        break;
+    case OptionSource::CommandLineSingleDash:
+        s << '-';
+        break;
+    default:
+        break;
+    }
+    s << bo.option;
+    if (bo.source == OptionSource::ProjectFile)
+        s << " (project)";
+}
+
+template <class Stream> void formatOptionValue(Stream &s, const OptionValue &ov)
+{
+    switch (ov.source) {
+    case OptionSource::CommandLine:
+        s << "--";
+        break;
+    case OptionSource::CommandLineSingleDash:
+        s << '-';
+        break;
+    default:
+        break;
+    }
+    s << ov.option << '=' << ov.value;
+    if (ov.source == OptionSource::ProjectFile)
+        s << " (project)";
+}
+
+QTextStream &operator<<(QTextStream &s, const BoolOption &bo)
+{
+    formatBoolOption(s, bo);
+    return s;
+}
+
+QTextStream &operator<<(QTextStream &s, const OptionValue &ov)
+{
+    formatOptionValue(s, ov);
+    return s;
+}
+
+QDebug operator<<(QDebug debug, const BoolOption &bo)
+{
+    QDebugStateSaver saver(debug);
+    debug.noquote();
+    debug.nospace();
+    formatBoolOption(debug, bo);
+    return debug;
+}
+
+QDebug operator<<(QDebug debug, const OptionValue &v)
+{
+    QDebugStateSaver saver(debug);
+    debug.noquote();
+    debug.nospace();
+    formatOptionValue(debug, v);
+    return debug;
+}
+
+QDebug operator<<(QDebug debug, const Options &v)
+{
+    QDebugStateSaver saver(debug);
+    debug.noquote();
+    debug.nospace();
+    debug << "Options(";
+    if (!v.boolOptions.isEmpty())
+        debug << "bools=" << v.boolOptions;
+    if (!v.valueOptions.isEmpty())
+        debug << ", option values=" << v.valueOptions;
+    if (!v.positionalArguments.isEmpty())
+        debug << ", pos=" << v.positionalArguments;
+    debug << ')';
+    return debug;
+}
+
+QTextStream &operator<<(QTextStream &s, const OptionDescription &od)
+{
+    if (!od.name.startsWith(u'-'))
+        s << "--";
+    s << od.name;
+    if (od.description.isEmpty()) { // For formatting {{"-s", ""}, {"--short", "descr"}}
+        s << ", ";
+    } else {
+        s << '\n';
+        const auto lines = QStringView{od.description}.split(u'\n');
+        for (const auto &line : lines)
+            s << "        " << line << '\n';
+        s << '\n';
+    }
+    return s;
+}
+
+QTextStream &operator<<(QTextStream &s, const OptionDescriptions &options)
+{
+    s.setFieldAlignment(QTextStream::AlignLeft);
+    for (const auto &od : options)
+        s << od;
+    return s;
+}
+
+OptionsParser::OptionsParser() noexcept = default;
+OptionsParser::~OptionsParser() = default;
+
+const QString &OptionsParser::pathSyntax()
+{
+    static const QString result =
+        u"<path>["_s + QDir::listSeparator() + u"<path>"_s
+        + QDir::listSeparator() + u"...]"_s;
+    return result;
+}
+
+bool OptionsParser::handleBoolOption(const QString &, OptionSource)
+{
+    return false;
+}
+
+bool OptionsParser::handleOption(const QString &, const QString &, OptionSource)
+{
+    return false;
+}
+
+void OptionsParser::process(Options *o)
+{
+    for (auto i = o->boolOptions.size() - 1; i >= 0; --i) {
+        const auto &opt = o->boolOptions.at(i);
+        if (handleBoolOption(opt.option, opt.source))
+            o->boolOptions.removeAt(i);
+    }
+    for (auto i = o->valueOptions.size() - 1; i >= 0; --i) {
+        const auto &opt = o->valueOptions.at(i);
+        if (handleOption(opt.option, opt.value, opt.source))
+            o->valueOptions.removeAt(i);
+    }
+}
+
+bool OptionsParserList::handleBoolOption(const QString &key, OptionSource source)
+{
+    for (const auto &p : std::as_const(m_parsers)) {
+        if (p->handleBoolOption(key, source))
+            return true;
+    }
+    return false;
+}
+
+bool OptionsParserList::handleOption(const QString &key, const QString &value, OptionSource source)
+{
+    for (const auto &p : std::as_const(m_parsers)) {
+        if (p->handleOption(key, value, source))
+            return true;
+    }
+    return false;
+}
+
+static void processOption(const QString &o, OptionSource source,
+                          BoolOptions *bools, OptionValues *values)
+{
+    const auto equals = o.indexOf(u'=');
+    if (equals == -1) {
+        bools->append({o.trimmed(), source});
+    } else {
+        QString key = o.left(equals).trimmed();
+        QString value = o.mid(equals + 1).trimmed();
+        if (!value.isEmpty())
+            values->append({key, value, source});
+    }
+}
+
+static void readProjectFile(const QString &name, Options *o)
+{
+    const auto startMarker = "[generator-project]"_ba;
+
+    QFile file(name);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
+        throw Exception(msgCannotOpenForReading(file));
+
+    if (file.atEnd() || file.readLine().trimmed() != startMarker)
+        throw Exception(msgMissingProjectFileMarker(name, startMarker));
+
+    while (!file.atEnd()) {
+        const QByteArray lineB = file.readLine().trimmed();
+        if (!lineB.isEmpty() && !lineB.startsWith('#')) {
+            processOption(QString::fromUtf8(lineB), OptionSource::ProjectFile,
+                          &o->boolOptions, &o->valueOptions);
+        }
+    }
+}
+
+void Options::setOptions(const QStringList &argv)
+{
+    const auto projectFileOption = "--project-file="_L1;
+    for (const auto &o : argv) {
+        if (o.startsWith(projectFileOption)) {
+            readProjectFile(o.sliced(projectFileOption.size()), this);
+        } else if (o.startsWith(u"--")) {
+            processOption(o.sliced(2), OptionSource::CommandLine,
+                          &boolOptions, &valueOptions);
+        } else if (o.startsWith(u'-')) {
+            processOption(o.sliced(1), OptionSource::CommandLineSingleDash,
+                          &boolOptions, &valueOptions);
+        } else {
+            positionalArguments.append(o);
+        }
+    }
+}
+
+QString Options::msgUnprocessedOptions() const
+{
+    QString result;
+    QTextStream str(&result);
+    for (const auto &b : boolOptions)
+        str << b << ' ';
+    for (const auto &v : valueOptions)
+        str << v << ' ';
+    return result.trimmed();
+}
diff --git a/sources/shiboken6/ApiExtractor/optionsparser.h b/sources/shiboken6/ApiExtractor/optionsparser.h
new file mode 100644
index 000000000..d5557dc15
--- /dev/null
+++ b/sources/shiboken6/ApiExtractor/optionsparser.h
@@ -0,0 +1,98 @@
+// 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 OPTIONSPARSER_H
+#define OPTIONSPARSER_H
+
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+
+#include <memory>
+
+QT_FORWARD_DECLARE_CLASS(QTextStream)
+
+enum class OptionSource
+{
+    CommandLine, // "--option"
+    CommandLineSingleDash, // "-o"
+    ProjectFile
+};
+
+struct BoolOption
+{
+    QString option;
+    OptionSource source = OptionSource::CommandLine;
+};
+
+struct OptionValue // --option=value pair
+{
+    QString option;
+    QString value;
+    OptionSource source = OptionSource::CommandLine;
+};
+
+using BoolOptions = QList<BoolOption>;
+using OptionValues = QList<OptionValue>;
+
+struct Options // Options from command line and project file
+{
+    void setOptions(const QStringList &argv);
+    QString msgUnprocessedOptions() const;
+
+    BoolOptions boolOptions;
+    OptionValues valueOptions;
+    QStringList positionalArguments;
+};
+
+struct OptionDescription // For help formatting
+{
+    QString name;
+    QString description;
+};
+
+using OptionDescriptions = QList<OptionDescription>;
+
+QTextStream &operator<<(QTextStream &s, const BoolOption &bo);
+QTextStream &operator<<(QTextStream &s, const OptionValue &ov);
+QTextStream &operator<<(QTextStream &s, const OptionDescription &od);
+QTextStream &operator<<(QTextStream &s, const OptionDescriptions &options);
+
+class OptionsParser
+{
+public:
+    Q_DISABLE_COPY_MOVE(OptionsParser)
+
+    virtual ~OptionsParser();
+
+    // Return true to indicate the option was processed.
+    virtual bool handleBoolOption(const QString &key, OptionSource source);
+    virtual bool handleOption(const QString &key, const QString &value, OptionSource source);
+
+    void process(Options *);
+
+    static const QString &pathSyntax();
+
+protected:
+    OptionsParser() noexcept;
+};
+
+class OptionsParserList : public OptionsParser
+{
+public:
+    using OptionsParserPtr = std::shared_ptr<OptionsParser>;
+
+    void append(const OptionsParserPtr &parser) { m_parsers.append(parser); }
+    void clear() { m_parsers.clear(); }
+
+    bool handleBoolOption(const QString &key, OptionSource source) override;
+    bool handleOption(const QString &key, const QString &value, OptionSource source) override;
+
+private:
+    QList<OptionsParserPtr> m_parsers;
+};
+
+QDebug operator<<(QDebug debug, const BoolOption &bo);
+QDebug operator<<(QDebug debug, const OptionValue &v);
+QDebug operator<<(QDebug debug, const Options &v);
+
+#endif // OPTIONSPARSER_H
diff --git a/sources/shiboken6/ApiExtractor/parser/codemodel.cpp b/sources/shiboken6/ApiExtractor/parser/codemodel.cpp
index 8c6279ee6..259a706dc 100644
--- a/sources/shiboken6/ApiExtractor/parser/codemodel.cpp
+++ b/sources/shiboken6/ApiExtractor/parser/codemodel.cpp
@@ -6,33 +6,24 @@
 #include "codemodel.h"
 
 #include <sourcelocation.h>
+#include <debughelpers_p.h>
 
 #include <QtCore/QDebug>
 #include <QtCore/QDir>
 #include <QtCore/QRegularExpression>
 
 #include <algorithm>
-#include <functional>
-#include <iostream>
 
 using namespace Qt::StringLiterals;
 
-// Predicate to find an item by name in a list of QSharedPointer<Item>
-template <class T> class ModelItemNamePredicate
-{
-public:
-    explicit ModelItemNamePredicate(const QString &name) : m_name(name) {}
-    bool operator()(const QSharedPointer<T> &item) const { return item->name() == m_name; }
-
-private:
-    const QString m_name;
-};
-
 template <class T>
-static QSharedPointer<T> findModelItem(const QList<QSharedPointer<T> > &list, const QString &name)
+static std::shared_ptr<T> findModelItem(const QList<std::shared_ptr<T> > &list,
+                                        QAnyStringView name)
 {
-    const auto it = std::find_if(list.cbegin(), list.cend(), ModelItemNamePredicate<T>(name));
-    return it != list.cend() ? *it : QSharedPointer<T>();
+    using ItemPtr = std::shared_ptr<T>;
+    auto pred = [name](const ItemPtr &item) { return item->name() == name; };
+    const auto it = std::find_if(list.cbegin(), list.cend(), pred);
+    return it != list.cend() ? *it : ItemPtr{};
 }
 
 // ---------------------------------------------------------------------------
@@ -53,7 +44,7 @@ void CodeModel::addFile(const FileModelItem &item)
     m_files.append(item);
 }
 
-FileModelItem CodeModel::findFile(const QString &name) const
+FileModelItem CodeModel::findFile(QAnyStringView name) const
 {
     return findModelItem(m_files, name);
 }
@@ -71,11 +62,11 @@ static CodeModelItem findRecursion(const ScopeModelItem &scope,
             return tp;
         if (TemplateTypeAliasModelItem tta = scope->findTemplateTypeAlias(nameSegment))
             return tta;
-        return CodeModelItem();
+        return {};
     }
     if (auto nestedClass = scope->findClass(nameSegment))
         return findRecursion(nestedClass, qualifiedName, segment + 1);
-    if (auto namespaceItem = qSharedPointerDynamicCast<_NamespaceModelItem>(scope)) {
+    if (auto namespaceItem = std::dynamic_pointer_cast<_NamespaceModelItem>(scope)) {
         for (const auto &nestedNamespace : namespaceItem->namespaces()) {
             if (nestedNamespace->name() == nameSegment) {
                 if (auto item = findRecursion(nestedNamespace, qualifiedName, segment + 1))
@@ -83,7 +74,7 @@ static CodeModelItem findRecursion(const ScopeModelItem &scope,
             }
         }
     }
-    return CodeModelItem();
+    return {};
 }
 
 CodeModelItem CodeModel::findItem(const QStringList &qualifiedName, const ScopeModelItem &scope)
@@ -120,7 +111,7 @@ QDebug operator<<(QDebug d, const CodeModel *m)
     d << "CodeModel(";
     if (m) {
         const NamespaceModelItem globalNamespaceP = m->globalNamespace();
-        if (globalNamespaceP.data())
+        if (globalNamespaceP)
             globalNamespaceP->formatDebug(d);
     } else {
         d << '0';
@@ -243,27 +234,17 @@ void _CodeModelItem::setEnclosingScope(const _ScopeModelItem *s)
     m_enclosingScope = s;
 }
 
-#ifndef QT_NO_DEBUG_STREAM
-template <class It>
-void formatSequence(QDebug &d, It i1, It i2, const char *separator=", ")
+_ScopeModelItem::_ScopeModelItem(CodeModel *model, int kind)
+    : _CodeModelItem(model, kind)
 {
-    for (It i = i1; i != i2; ++i) {
-        if (i != i1)
-            d << separator;
-        d << *i;
-    }
 }
 
-template <class It>
-static void formatPtrSequence(QDebug &d, It i1, It i2, const char *separator=", ")
+_ScopeModelItem::_ScopeModelItem(CodeModel *model, const QString &name, int kind)
+    : _CodeModelItem(model, name, kind)
 {
-    for (It i = i1; i != i2; ++i) {
-        if (i != i1)
-            d << separator;
-        d << i->data();
-    }
 }
 
+#ifndef QT_NO_DEBUG_STREAM
 void _CodeModelItem::formatKind(QDebug &d, int k)
 {
     switch (k) {
@@ -373,6 +354,16 @@ bool _ClassModelItem::extendsClass(const QString &name) const
     return false;
 }
 
+_ClassModelItem::_ClassModelItem(CodeModel *model, int kind)
+    : _ScopeModelItem(model, kind)
+{
+}
+
+_ClassModelItem::_ClassModelItem(CodeModel *model, const QString &name, int kind)
+    : _ScopeModelItem(model, name, kind)
+{
+}
+
 const QList<_ClassModelItem::UsingMember> &_ClassModelItem::usingMembers() const
 {
     return m_usingMembers;
@@ -458,7 +449,7 @@ FunctionModelItem _ScopeModelItem::declaredFunction(const FunctionModelItem &ite
             return fun;
 
     }
-    return FunctionModelItem();
+    return {};
 }
 
 _ScopeModelItem::~_ScopeModelItem() = default;
@@ -627,52 +618,46 @@ void  _ScopeModelItem::formatDebug(QDebug &d) const
 }
 #endif // !QT_NO_DEBUG_STREAM
 
-namespace {
 // Predicate to match a non-template class name against the class list.
 // "Vector" should match "Vector" as well as "Vector<T>" (as seen for methods
 // from within the class "Vector").
-class ClassNamePredicate
+static bool matchClassNameNonTemplatePart(const ClassModelItem &item, const QString &name)
 {
-public:
-    explicit ClassNamePredicate(const QString &name) : m_name(name) {}
-    bool operator()(const ClassModelItem &item) const
-    {
-        const QString &itemName = item->name();
-        if (!itemName.startsWith(m_name))
-            return false;
-        return itemName.size() == m_name.size() || itemName.at(m_name.size()) == u'<';
-    }
-
-private:
-    const QString m_name;
-};
-} // namespace
+    const QString &itemName = item->name();
+    if (!itemName.startsWith(name))
+        return false;
+    return itemName.size() == name.size() || itemName.at(name.size()) == u'<';
+}
 
 ClassModelItem _ScopeModelItem::findClass(const QString &name) const
 {
     // A fully qualified template is matched by name only
     const ClassList::const_iterator it = name.contains(u'<')
-        ? std::find_if(m_classes.begin(), m_classes.end(), ModelItemNamePredicate<_ClassModelItem>(name))
-        : std::find_if(m_classes.begin(), m_classes.end(), ClassNamePredicate(name));
+        ? std::find_if(m_classes.begin(), m_classes.end(),
+                       [&name](const ClassModelItem &item) {
+                               return item->name() == name; })
+        : std::find_if(m_classes.begin(), m_classes.end(),
+                       [&name](const ClassModelItem &item) {
+                               return matchClassNameNonTemplatePart(item, name); });
     return it != m_classes.end() ? *it : ClassModelItem();
 }
 
-VariableModelItem _ScopeModelItem::findVariable(const QString &name) const
+VariableModelItem _ScopeModelItem::findVariable(QAnyStringView name) const
 {
     return findModelItem(m_variables, name);
 }
 
-TypeDefModelItem _ScopeModelItem::findTypeDef(const QString &name) const
+TypeDefModelItem _ScopeModelItem::findTypeDef(QAnyStringView name) const
 {
     return findModelItem(m_typeDefs, name);
 }
 
-TemplateTypeAliasModelItem _ScopeModelItem::findTemplateTypeAlias(const QString &name) const
+TemplateTypeAliasModelItem _ScopeModelItem::findTemplateTypeAlias(QAnyStringView name) const
 {
     return findModelItem(m_templateTypeAliases, name);
 }
 
-EnumModelItem _ScopeModelItem::findEnum(const QString &name) const
+EnumModelItem _ScopeModelItem::findEnum(QAnyStringView name) const
 {
     return findModelItem(m_enums, name);
 }
@@ -724,8 +709,8 @@ _ScopeModelItem::FindEnumByValueReturn
         if (searchSiblingNamespaces && scope->kind() == Kind_Namespace) {
             if (auto *enclosingNamespace = dynamic_cast<const _NamespaceModelItem *>(enclosingScope)) {
                 for (const auto &sibling : enclosingNamespace->namespaces()) {
-                    if (sibling.data() != scope && sibling->name() == scope->name()) {
-                        if (const auto e = findEnumByValueRecursion(sibling.data(),
+                    if (sibling.get() != scope && sibling->name() == scope->name()) {
+                        if (const auto e = findEnumByValueRecursion(sibling.get(),
                                                                     fullValue, enumValue, false)) {
                             return e;
                         }
@@ -741,8 +726,8 @@ _ScopeModelItem::FindEnumByValueReturn
     // PYSIDE-331: We need to also search the base classes.
     if (auto *classItem = dynamic_cast<const _ClassModelItem *>(scope)) {
         for (const auto &base : classItem->baseClasses()) {
-            if (!base.klass.isNull()) {
-                auto *c = base.klass.data();
+            if (base.klass) {
+                auto *c = base.klass.get();
                 if (const auto e = findEnumByValueRecursion(c, fullValue, enumValue))
                     return e;
             }
@@ -761,7 +746,7 @@ _ScopeModelItem::FindEnumByValueReturn
     return findEnumByValueRecursion(this, value, enumValue);
 }
 
-FunctionList _ScopeModelItem::findFunctions(const QString &name) const
+FunctionList _ScopeModelItem::findFunctions(QAnyStringView name) const
 {
     FunctionList result;
     for (const FunctionModelItem &func : m_functions) {
@@ -772,17 +757,25 @@ FunctionList _ScopeModelItem::findFunctions(const QString &name) const
 }
 
 // ---------------------------------------------------------------------------
-_NamespaceModelItem::~_NamespaceModelItem()
+_NamespaceModelItem::_NamespaceModelItem(CodeModel *model, int kind)
+    : _ScopeModelItem(model, kind)
 {
 }
 
+_NamespaceModelItem::_NamespaceModelItem(CodeModel *model, const QString &name, int kind)
+    : _ScopeModelItem(model, name, kind)
+{
+}
+
+_NamespaceModelItem::~_NamespaceModelItem() = default;
+
 void _NamespaceModelItem::addNamespace(NamespaceModelItem item)
 {
     item->setEnclosingScope(this);
     m_namespaces.append(item);
 }
 
-NamespaceModelItem _NamespaceModelItem::findNamespace(const QString &name) const
+NamespaceModelItem _NamespaceModelItem::findNamespace(QAnyStringView name) const
 {
     return findModelItem(m_namespaces, name);
 }
@@ -814,10 +807,18 @@ void _NamespaceModelItem::formatDebug(QDebug &d) const
 #endif // !QT_NO_DEBUG_STREAM
 
 // ---------------------------------------------------------------------------
-_ArgumentModelItem::~_ArgumentModelItem()
+_ArgumentModelItem::_ArgumentModelItem(CodeModel *model, int kind)
+    : _CodeModelItem(model, kind)
 {
 }
 
+_ArgumentModelItem::_ArgumentModelItem(CodeModel *model, const QString &name, int kind)
+    : _CodeModelItem(model, name, kind)
+{
+}
+
+_ArgumentModelItem::~_ArgumentModelItem() = default;
+
 TypeInfo _ArgumentModelItem::type() const
 {
     return m_type;
@@ -838,11 +839,23 @@ void _ArgumentModelItem::setDefaultValue(bool defaultValue)
     m_defaultValue = defaultValue;
 }
 
+bool _ArgumentModelItem::scopeResolution() const
+{
+    return m_scopeResolution;
+}
+
+void _ArgumentModelItem::setScopeResolution(bool v)
+{
+    m_scopeResolution = v;
+}
+
 #ifndef QT_NO_DEBUG_STREAM
 void _ArgumentModelItem::formatDebug(QDebug &d) const
 {
     _CodeModelItem::formatDebug(d);
     d << ", type=" << m_type;
+    if (m_scopeResolution)
+        d << ", [m_scope resolution]";
     if (m_defaultValue)
         d << ", defaultValue=\"" << m_defaultValueExpression << '"';
 }
@@ -877,6 +890,16 @@ bool _FunctionModelItem::isSimilar(const FunctionModelItem &other) const
     return true;
 }
 
+_FunctionModelItem::_FunctionModelItem(CodeModel *model, int kind)
+    : _MemberModelItem(model, kind), m_flags(0)
+{
+}
+
+_FunctionModelItem::_FunctionModelItem(CodeModel *model, const QString &name, int kind)
+    : _MemberModelItem(model, name, kind), m_flags(0)
+{
+}
+
 ArgumentList _FunctionModelItem::arguments() const
 {
     return m_arguments;
@@ -907,6 +930,16 @@ void _FunctionModelItem::setVariadics(bool isVariadics)
     m_isVariadics = isVariadics;
 }
 
+bool _FunctionModelItem::scopeResolution() const
+{
+    return m_scopeResolution;
+}
+
+void _FunctionModelItem::setScopeResolution(bool v)
+{
+    m_scopeResolution = v;
+}
+
 bool _FunctionModelItem::isDefaultConstructor() const
 {
     return m_functionType == CodeModel::Constructor
@@ -969,66 +1002,16 @@ void _FunctionModelItem::setDeleted(bool d)
     m_isDeleted = d;
 }
 
-bool _FunctionModelItem::isDeprecated() const
-{
-    return m_isDeprecated;
-}
-
-void _FunctionModelItem::setDeprecated(bool d)
-{
-    m_isDeprecated = d;
-}
-
-bool _FunctionModelItem::isVirtual() const
-{
-    return m_isVirtual;
-}
-
-void _FunctionModelItem::setVirtual(bool isVirtual)
-{
-    m_isVirtual = isVirtual;
-}
-
 bool _FunctionModelItem::isInline() const
 {
     return m_isInline;
 }
 
-bool _FunctionModelItem::isOverride() const
-{
-    return m_isOverride;
-}
-
-void _FunctionModelItem::setOverride(bool o)
-{
-    m_isOverride = o;
-}
-
-bool _FunctionModelItem::isFinal() const
-{
-    return m_isFinal;
-}
-
-void _FunctionModelItem::setFinal(bool f)
-{
-    m_isFinal = f;
-}
-
 void _FunctionModelItem::setInline(bool isInline)
 {
     m_isInline = isInline;
 }
 
-bool _FunctionModelItem::isExplicit() const
-{
-    return m_isExplicit;
-}
-
-void _FunctionModelItem::setExplicit(bool isExplicit)
-{
-    m_isExplicit = isExplicit;
-}
-
 bool _FunctionModelItem::isHiddenFriend() const
 {
     return m_isHiddenFriend;
@@ -1039,27 +1022,6 @@ void _FunctionModelItem::setHiddenFriend(bool f)
     m_isHiddenFriend = f;
 }
 
-bool _FunctionModelItem::isAbstract() const
-{
-    return m_isAbstract;
-}
-
-void _FunctionModelItem::setAbstract(bool isAbstract)
-{
-    m_isAbstract = isAbstract;
-}
-
-// Qt
-bool _FunctionModelItem::isInvokable() const
-{
-    return m_isInvokable;
-}
-
-void _FunctionModelItem::setInvokable(bool isInvokable)
-{
-    m_isInvokable = isInvokable;
-}
-
 QString _FunctionModelItem::typeSystemSignature() const  // For dumping out type system files
 {
     QString result;
@@ -1184,20 +1146,22 @@ void _FunctionModelItem::formatDebug(QDebug &d) const
         d << " [deleted!]";
     if (m_isInline)
         d << " [inline]";
-    if (m_isVirtual)
+    if (m_attributes.testFlag(FunctionAttribute::Virtual))
         d << " [virtual]";
-    if (m_isOverride)
+    if (m_attributes.testFlag(FunctionAttribute::Override))
         d << " [override]";
-    if (m_isDeprecated)
+    if (m_attributes.testFlag(FunctionAttribute::Deprecated))
         d << " [deprecated]";
-    if (m_isFinal)
+    if (m_attributes.testFlag(FunctionAttribute::Final))
         d << " [final]";
-    if (m_isAbstract)
+    if (m_attributes.testFlag(FunctionAttribute::Abstract))
         d << " [abstract]";
-    if (m_isExplicit)
+    if (m_attributes.testFlag(FunctionAttribute::Explicit))
         d << " [explicit]";
     if (m_isInvokable)
         d << " [invokable]";
+    if (m_scopeResolution)
+        d << " [scope resolution]";
     formatModelItemList(d, ", arguments=", m_arguments);
     if (m_isVariadics)
         d << ",...";
@@ -1205,6 +1169,16 @@ void _FunctionModelItem::formatDebug(QDebug &d) const
 #endif // !QT_NO_DEBUG_STREAM
 
 // ---------------------------------------------------------------------------
+_TypeDefModelItem::_TypeDefModelItem(CodeModel *model, int kind)
+    : _CodeModelItem(model, kind)
+{
+}
+
+_TypeDefModelItem::_TypeDefModelItem(CodeModel *model, const QString &name, int kind)
+    : _CodeModelItem(model, name, kind)
+{
+}
+
 TypeInfo _TypeDefModelItem::type() const
 {
     return m_type;
@@ -1266,6 +1240,16 @@ void _TemplateTypeAliasModelItem::formatDebug(QDebug &d) const
 #endif // !QT_NO_DEBUG_STREAM
 
 // ---------------------------------------------------------------------------
+_EnumModelItem::_EnumModelItem(CodeModel *model, const QString &name, int kind)
+    : _CodeModelItem(model, name, kind)
+{
+}
+
+_EnumModelItem::_EnumModelItem(CodeModel *model, int kind)
+    : _CodeModelItem(model, kind)
+{
+}
+
 Access _EnumModelItem::accessPolicy() const
 {
     return m_accessPolicy;
@@ -1307,6 +1291,16 @@ void _EnumModelItem::setSigned(bool s)
     m_signed = s;
 }
 
+QString _EnumModelItem::underlyingType() const
+{
+    return m_underlyingType;
+}
+
+void _EnumModelItem::setUnderlyingType(const QString &underlyingType)
+{
+    m_underlyingType = underlyingType;
+}
+
 bool _EnumModelItem::isDeprecated() const
 {
     return m_deprecated;
@@ -1342,6 +1336,16 @@ void _EnumModelItem::formatDebug(QDebug &d) const
 // ---------------------------------------------------------------------------
 _EnumeratorModelItem::~_EnumeratorModelItem() = default;
 
+_EnumeratorModelItem::_EnumeratorModelItem(CodeModel *model, int kind)
+    : _CodeModelItem(model, kind)
+{
+}
+
+_EnumeratorModelItem::_EnumeratorModelItem(CodeModel *model, const QString &name, int kind)
+    : _CodeModelItem(model, name, kind)
+{
+}
+
 QString _EnumeratorModelItem::stringValue() const
 {
     return m_stringValue;
@@ -1375,6 +1379,17 @@ void _EnumeratorModelItem::formatDebug(QDebug &d) const
 // ---------------------------------------------------------------------------
 _TemplateParameterModelItem::~_TemplateParameterModelItem() = default;
 
+_TemplateParameterModelItem::_TemplateParameterModelItem(CodeModel *model, int kind)
+    : _CodeModelItem(model, kind)
+{
+}
+
+_TemplateParameterModelItem::_TemplateParameterModelItem(CodeModel *model,
+                                                         const QString &name, int kind)
+    : _CodeModelItem(model, name, kind)
+{
+}
+
 TypeInfo _TemplateParameterModelItem::type() const
 {
     return m_type;
@@ -1438,6 +1453,16 @@ void _MemberModelItem::setStatic(bool isStatic)
     m_isStatic = isStatic;
 }
 
+_MemberModelItem::_MemberModelItem(CodeModel *model, int kind)
+    : _CodeModelItem(model, kind), m_flags(0)
+{
+}
+
+_MemberModelItem::_MemberModelItem(CodeModel *model, const QString &name, int kind)
+    : _CodeModelItem(model, name, kind), m_flags(0)
+{
+}
+
 bool _MemberModelItem::isConstant() const
 {
     return m_isConstant;
diff --git a/sources/shiboken6/ApiExtractor/parser/codemodel.h b/sources/shiboken6/ApiExtractor/parser/codemodel.h
index 97a851995..b31c09163 100644
--- a/sources/shiboken6/ApiExtractor/parser/codemodel.h
+++ b/sources/shiboken6/ApiExtractor/parser/codemodel.h
@@ -12,7 +12,6 @@
 #include "typeinfo.h"
 
 #include <QtCore/QHash>
-#include <QtCore/QPair>
 #include <QtCore/QSet>
 #include <QtCore/QString>
 #include <QtCore/QStringList>
@@ -20,6 +19,7 @@
 #include <QtCore/QWeakPointer>
 
 #include <optional>
+#include <utility>
 
 QT_FORWARD_DECLARE_CLASS(QDebug)
 
@@ -32,7 +32,7 @@ class CodeModel
 {
     Q_GADGET
 public:
-    Q_DISABLE_COPY(CodeModel)
+    Q_DISABLE_COPY_MOVE(CodeModel)
 
     enum FunctionType {
         Normal,
@@ -74,7 +74,7 @@ public:
     NamespaceModelItem globalNamespace() const;
 
     void addFile(const FileModelItem &item);
-    FileModelItem findFile(const QString &name) const;
+    FileModelItem findFile(QAnyStringView name) const;
 
     static CodeModelItem findItem(const QStringList &qualifiedName,
                                   const ScopeModelItem &scope);
@@ -91,8 +91,9 @@ QDebug operator<<(QDebug d, const CodeModel *m);
 
 class _CodeModelItem
 {
-    Q_DISABLE_COPY(_CodeModelItem)
 public:
+    Q_DISABLE_COPY_MOVE(_CodeModelItem)
+
     enum Kind {
         /* These are bit-flags resembling inheritance */
         Kind_Scope = 0x1,
@@ -175,6 +176,7 @@ QDebug operator<<(QDebug d, const _CodeModelItem *t);
 class _ScopeModelItem: public _CodeModelItem
 {
 public:
+    Q_DISABLE_COPY_MOVE(_ScopeModelItem)
     DECLARE_MODEL_NODE(Scope)
 
     ~_ScopeModelItem();
@@ -194,21 +196,21 @@ public:
     void addVariable(const VariableModelItem &item);
 
     ClassModelItem findClass(const QString &name) const;
-    EnumModelItem findEnum(const QString &name) const;
+    EnumModelItem findEnum(QAnyStringView name) const;
 
     struct FindEnumByValueReturn
     {
-        operator bool() const { return !item.isNull(); }
+        operator bool() const { return bool(item); }
 
         EnumModelItem item;
         QString qualifiedName;
     };
     FindEnumByValueReturn findEnumByValue(QStringView value) const;
 
-    FunctionList findFunctions(const QString &name) const;
-    TypeDefModelItem findTypeDef(const QString &name) const;
-    TemplateTypeAliasModelItem findTemplateTypeAlias(const QString &name) const;
-    VariableModelItem findVariable(const QString &name) const;
+    FunctionList findFunctions(QAnyStringView name) const;
+    TypeDefModelItem findTypeDef(QAnyStringView name) const;
+    TemplateTypeAliasModelItem findTemplateTypeAlias(QAnyStringView name) const;
+    VariableModelItem findVariable(QAnyStringView name) const;
 
     void addEnumsDeclaration(const QString &enumsDeclaration);
     QStringList enumsDeclarations() const { return m_enumsDeclarations; }
@@ -223,10 +225,9 @@ public:
 #endif
 
 protected:
-    explicit _ScopeModelItem(CodeModel *model, int kind = __node_kind)
-        : _CodeModelItem(model, kind) {}
-    explicit _ScopeModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _CodeModelItem(model, name, kind) {}
+    explicit _ScopeModelItem(CodeModel *model, int kind = __node_kind);
+    explicit _ScopeModelItem(CodeModel *model, const QString &name,
+                             int kind = __node_kind);
 
     void appendScope(const _ScopeModelItem &other);
 
@@ -258,6 +259,7 @@ private:
 class _ClassModelItem: public _ScopeModelItem
 {
 public:
+    Q_DISABLE_COPY_MOVE(_ClassModelItem)
     DECLARE_MODEL_NODE(Class)
 
     struct BaseClass
@@ -274,10 +276,9 @@ public:
         Access access = Access::Public;
     };
 
-    explicit _ClassModelItem(CodeModel *model, int kind = __node_kind)
-        : _ScopeModelItem(model, kind), m_classType(CodeModel::Class) {}
-    explicit _ClassModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _ScopeModelItem(model, name, kind), m_classType(CodeModel::Class) {}
+    explicit _ClassModelItem(CodeModel *model, int kind = __node_kind);
+    explicit _ClassModelItem(CodeModel *model, const QString &name,
+                             int kind = __node_kind);
     ~_ClassModelItem();
 
     const QList<BaseClass> &baseClasses() const { return m_baseClasses; }
@@ -313,7 +314,7 @@ private:
     QList<BaseClass> m_baseClasses;
     QList<UsingMember> m_usingMembers;
     TemplateParameterList m_templateParameters;
-    CodeModel::ClassType m_classType;
+    CodeModel::ClassType m_classType = CodeModel::Class;
 
     QStringList m_propertyDeclarations;
     bool m_final = false;
@@ -322,12 +323,12 @@ private:
 class _NamespaceModelItem: public _ScopeModelItem
 {
 public:
+    Q_DISABLE_COPY_MOVE(_NamespaceModelItem)
     DECLARE_MODEL_NODE(Namespace)
 
-    explicit _NamespaceModelItem(CodeModel *model, int kind = __node_kind)
-        : _ScopeModelItem(model, kind) {}
-    explicit _NamespaceModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _ScopeModelItem(model, name, kind) {}
+    explicit _NamespaceModelItem(CodeModel *model, int kind = __node_kind);
+    explicit _NamespaceModelItem(CodeModel *model, const QString &name,
+                                 int kind = __node_kind);
     ~_NamespaceModelItem();
 
     const NamespaceList &namespaces() const { return m_namespaces; }
@@ -337,7 +338,7 @@ public:
 
     void addNamespace(NamespaceModelItem item);
 
-    NamespaceModelItem findNamespace(const QString &name) const;
+    NamespaceModelItem findNamespace(QAnyStringView name) const;
 
     void appendNamespace(const _NamespaceModelItem &other);
 
@@ -353,24 +354,23 @@ private:
 class _FileModelItem: public _NamespaceModelItem
 {
 public:
+    Q_DISABLE_COPY_MOVE(_FileModelItem)
     DECLARE_MODEL_NODE(File)
 
-    explicit _FileModelItem(CodeModel *model, int kind = __node_kind)
-        : _NamespaceModelItem(model, kind) {}
-    explicit _FileModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _NamespaceModelItem(model, name, kind) {}
+    using _NamespaceModelItem::_NamespaceModelItem;
+
     ~_FileModelItem();
 };
 
 class _ArgumentModelItem: public _CodeModelItem
 {
 public:
+    Q_DISABLE_COPY_MOVE(_ArgumentModelItem)
     DECLARE_MODEL_NODE(Argument)
 
-    explicit _ArgumentModelItem(CodeModel *model, int kind = __node_kind)
-        : _CodeModelItem(model, kind), m_defaultValue(false) {}
-    explicit _ArgumentModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _CodeModelItem(model, name, kind), m_defaultValue(false) {}
+    explicit _ArgumentModelItem(CodeModel *model, int kind = __node_kind);
+    explicit _ArgumentModelItem(CodeModel *model, const QString &name,
+                                int kind = __node_kind);
     ~_ArgumentModelItem();
 
     TypeInfo type() const;
@@ -382,6 +382,10 @@ public:
     QString defaultValueExpression() const { return m_defaultValueExpression; }
     void setDefaultValueExpression(const QString &expr) { m_defaultValueExpression = expr; }
 
+    // Argument type has scope resolution "::ArgumentType"
+    bool scopeResolution() const;
+    void setScopeResolution(bool v);
+
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &d) const override;
 #endif
@@ -389,18 +393,19 @@ public:
 private:
     TypeInfo m_type;
     QString m_defaultValueExpression;
-    bool m_defaultValue;
+    bool m_defaultValue = false;
+    bool m_scopeResolution = false;
 };
 
 class _MemberModelItem: public _CodeModelItem
 {
 public:
+    Q_DISABLE_COPY_MOVE(_MemberModelItem)
     DECLARE_MODEL_NODE(Member)
 
-    explicit _MemberModelItem(CodeModel *model, int kind = __node_kind)
-        : _CodeModelItem(model, kind), m_accessPolicy(Access::Public), m_flags(0) {}
-    explicit _MemberModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _CodeModelItem(model, name, kind), m_accessPolicy(Access::Public), m_flags(0) {}
+    explicit _MemberModelItem(CodeModel *model, int kind = __node_kind);
+    explicit _MemberModelItem(CodeModel *model, const QString &name,
+                              int kind = __node_kind);
     ~_MemberModelItem();
 
     bool isConstant() const;
@@ -443,7 +448,7 @@ public:
 private:
     TemplateParameterList m_templateParameters;
     TypeInfo m_type;
-    Access m_accessPolicy;
+    Access m_accessPolicy = Access::Public;
     union {
         struct {
             uint m_isConstant: 1;
@@ -463,12 +468,12 @@ private:
 class _FunctionModelItem: public _MemberModelItem
 {
 public:
+    Q_DISABLE_COPY_MOVE(_FunctionModelItem)
     DECLARE_MODEL_NODE(Function)
 
-    explicit _FunctionModelItem(CodeModel *model, int kind = __node_kind)
-        : _MemberModelItem(model, kind), m_functionType(CodeModel::Normal), m_flags(0) {}
-    explicit _FunctionModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _MemberModelItem(model, name, kind), m_functionType(CodeModel::Normal), m_flags(0) {}
+    explicit _FunctionModelItem(CodeModel *model, int kind = __node_kind);
+    explicit _FunctionModelItem(CodeModel *model, const QString &name,
+                                int kind = __node_kind);
     ~_FunctionModelItem();
 
     ArgumentList arguments() const;
@@ -480,39 +485,25 @@ public:
 
     static std::optional<CodeModel::FunctionType> functionTypeFromName(QStringView name);
 
+    FunctionAttributes attributes() const { return m_attributes; }
+    void setAttributes(FunctionAttributes a) { m_attributes = a; }
+    void setAttribute(FunctionAttribute a, bool on = true) { m_attributes.setFlag(a, on); }
+
     bool isDeleted() const;
     void setDeleted(bool d);
 
-    bool isDeprecated() const;
-    void setDeprecated(bool d);
-
-    bool isVirtual() const;
-    void setVirtual(bool isVirtual);
-
-    bool isOverride() const;
-    void setOverride(bool o);
-
-    bool isFinal() const;
-    void setFinal(bool f);
-
     bool isInline() const;
     void setInline(bool isInline);
 
-    bool isExplicit() const;
-    void setExplicit(bool isExplicit);
-
     bool isHiddenFriend() const;
     void setHiddenFriend(bool f);
 
-    bool isInvokable() const; // Qt
-    void setInvokable(bool isInvokable); // Qt
-
-    bool isAbstract() const;
-    void setAbstract(bool isAbstract);
-
     bool isVariadics() const;
     void setVariadics(bool isVariadics);
 
+    bool scopeResolution() const; // Return type has scope resolution "::ReturnType"
+    void setScopeResolution(bool v);
+
     bool isDefaultConstructor() const;
     bool isSpaceshipOperator() const;
 
@@ -538,20 +529,16 @@ private:
     CodeModel::FunctionType _determineTypeHelper() const;
 
     ArgumentList m_arguments;
-    CodeModel::FunctionType m_functionType;
+    FunctionAttributes m_attributes;
+    CodeModel::FunctionType m_functionType = CodeModel::Normal;
     union {
         struct {
             uint m_isDeleted: 1;
-            uint m_isVirtual: 1;
-            uint m_isOverride: 1;
-            uint m_isFinal: 1;
-            uint m_isDeprecated: 1;
             uint m_isInline: 1;
-            uint m_isAbstract: 1;
-            uint m_isExplicit: 1;
             uint m_isVariadics: 1;
             uint m_isHiddenFriend: 1;
             uint m_isInvokable : 1; // Qt
+            uint m_scopeResolution: 1;
         };
         uint m_flags;
     };
@@ -563,10 +550,7 @@ class _VariableModelItem: public _MemberModelItem
 public:
     DECLARE_MODEL_NODE(Variable)
 
-    explicit _VariableModelItem(CodeModel *model, int kind = __node_kind)
-        : _MemberModelItem(model, kind) {}
-    explicit _VariableModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _MemberModelItem(model, name, kind) {}
+    using _MemberModelItem::_MemberModelItem;
 };
 
 class _TypeDefModelItem: public _CodeModelItem
@@ -574,10 +558,9 @@ class _TypeDefModelItem: public _CodeModelItem
 public:
     DECLARE_MODEL_NODE(TypeDef)
 
-    explicit _TypeDefModelItem(CodeModel *model, int kind = __node_kind)
-        : _CodeModelItem(model, kind) {}
-    explicit _TypeDefModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _CodeModelItem(model, name, kind) {}
+    explicit _TypeDefModelItem(CodeModel *model, int kind = __node_kind);
+    explicit _TypeDefModelItem(CodeModel *model, const QString &name,
+                               int kind = __node_kind);
 
     TypeInfo type() const;
     void setType(const TypeInfo &type);
@@ -617,12 +600,11 @@ private:
 class _EnumModelItem: public _CodeModelItem
 {
 public:
+    Q_DISABLE_COPY_MOVE(_EnumModelItem)
     DECLARE_MODEL_NODE(Enum)
 
-    explicit _EnumModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _CodeModelItem(model, name, kind) {}
-    explicit _EnumModelItem(CodeModel *model, int kind = __node_kind)
-        : _CodeModelItem(model, kind) {}
+    explicit _EnumModelItem(CodeModel *model, const QString &name, int kind = __node_kind);
+    explicit _EnumModelItem(CodeModel *model, int kind = __node_kind);
     ~_EnumModelItem();
 
     Access accessPolicy() const;
@@ -647,7 +629,11 @@ public:
     bool isSigned() const;
     void setSigned(bool s);
 
+    QString underlyingType() const;
+    void setUnderlyingType(const QString &underlyingType);
+
 private:
+    QString m_underlyingType;
     Access m_accessPolicy = Access::Public;
     EnumeratorList m_enumerators;
     EnumKind m_enumKind = CEnum;
@@ -658,12 +644,12 @@ private:
 class _EnumeratorModelItem: public _CodeModelItem
 {
 public:
+    Q_DISABLE_COPY_MOVE(_EnumeratorModelItem)
     DECLARE_MODEL_NODE(Enumerator)
 
-    explicit _EnumeratorModelItem(CodeModel *model, int kind = __node_kind)
-        : _CodeModelItem(model, kind) {}
-    explicit _EnumeratorModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _CodeModelItem(model, name, kind) {}
+    explicit _EnumeratorModelItem(CodeModel *model, int kind = __node_kind);
+    explicit _EnumeratorModelItem(CodeModel *model, const QString &name,
+                                  int kind = __node_kind);
     ~_EnumeratorModelItem();
 
     QString stringValue() const;
@@ -688,12 +674,12 @@ private:
 class _TemplateParameterModelItem: public _CodeModelItem
 {
 public:
+    Q_DISABLE_COPY_MOVE(_TemplateParameterModelItem)
     DECLARE_MODEL_NODE(TemplateParameter)
 
-    explicit _TemplateParameterModelItem(CodeModel *model, int kind = __node_kind)
-        : _CodeModelItem(model, kind), m_defaultValue(false) {}
-    explicit _TemplateParameterModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _CodeModelItem(model, name, kind), m_defaultValue(false) {}
+    explicit _TemplateParameterModelItem(CodeModel *model, int kind = __node_kind);
+    explicit _TemplateParameterModelItem(CodeModel *model, const QString &name,
+                                         int kind = __node_kind);
     ~_TemplateParameterModelItem();
 
     TypeInfo type() const;
@@ -708,9 +694,7 @@ public:
 
 private:
     TypeInfo m_type;
-    bool m_defaultValue;
+    bool m_defaultValue = false;
 };
 
 #endif // CODEMODEL_H
-
-// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/sources/shiboken6/ApiExtractor/parser/codemodel_enums.h b/sources/shiboken6/ApiExtractor/parser/codemodel_enums.h
index 1a058bdfe..e5c429bd0 100644
--- a/sources/shiboken6/ApiExtractor/parser/codemodel_enums.h
+++ b/sources/shiboken6/ApiExtractor/parser/codemodel_enums.h
@@ -4,6 +4,8 @@
 #ifndef CODEMODEL_ENUMS_H
 #define CODEMODEL_ENUMS_H
 
+#include <QtCore/qflags.h>
+
 enum ReferenceType {
     NoReference,
     LValueReference,
@@ -43,4 +45,17 @@ enum class Access
     Public
 };
 
+enum class FunctionAttribute {
+    Abstract   = 0x00000001,
+    Static     = 0x00000002,
+    Virtual    = 0x00000004,
+    Override   = 0x00000008,
+    Final      = 0x00000010,
+    Deprecated = 0x00000020, // Code annotation
+    Explicit   = 0x00000040, // Constructor
+};
+
+Q_DECLARE_FLAGS(FunctionAttributes, FunctionAttribute)
+Q_DECLARE_OPERATORS_FOR_FLAGS(FunctionAttributes)
+
 #endif // CODEMODEL_ENUMS_H
diff --git a/sources/shiboken6/ApiExtractor/parser/codemodel_fwd.h b/sources/shiboken6/ApiExtractor/parser/codemodel_fwd.h
index a3adf6678..f0a25c9db 100644
--- a/sources/shiboken6/ApiExtractor/parser/codemodel_fwd.h
+++ b/sources/shiboken6/ApiExtractor/parser/codemodel_fwd.h
@@ -7,7 +7,8 @@
 #define CODEMODEL_FWD_H
 
 #include <QtCore/QList>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
 
 // forward declarations
 class CodeModel;
@@ -27,20 +28,20 @@ class _VariableModelItem;
 class _MemberModelItem;
 class TypeInfo;
 
-using ArgumentModelItem = QSharedPointer<_ArgumentModelItem>;
-using ClassModelItem = QSharedPointer<_ClassModelItem>;
-using CodeModelItem = QSharedPointer<_CodeModelItem>;
-using EnumModelItem = QSharedPointer<_EnumModelItem>;
-using EnumeratorModelItem = QSharedPointer<_EnumeratorModelItem>;
-using FileModelItem = QSharedPointer<_FileModelItem>;
-using FunctionModelItem = QSharedPointer<_FunctionModelItem>;
-using NamespaceModelItem = QSharedPointer<_NamespaceModelItem>;
-using ScopeModelItem = QSharedPointer<_ScopeModelItem>;
-using TemplateParameterModelItem = QSharedPointer<_TemplateParameterModelItem>;
-using TypeDefModelItem = QSharedPointer<_TypeDefModelItem>;
-using TemplateTypeAliasModelItem = QSharedPointer<_TemplateTypeAliasModelItem>;
-using VariableModelItem = QSharedPointer<_VariableModelItem>;
-using MemberModelItem = QSharedPointer<_MemberModelItem>;
+using ArgumentModelItem = std::shared_ptr<_ArgumentModelItem>;
+using ClassModelItem = std::shared_ptr<_ClassModelItem>;
+using CodeModelItem = std::shared_ptr<_CodeModelItem>;
+using EnumModelItem = std::shared_ptr<_EnumModelItem>;
+using EnumeratorModelItem = std::shared_ptr<_EnumeratorModelItem>;
+using FileModelItem = std::shared_ptr<_FileModelItem>;
+using FunctionModelItem = std::shared_ptr<_FunctionModelItem>;
+using NamespaceModelItem = std::shared_ptr<_NamespaceModelItem>;
+using ScopeModelItem = std::shared_ptr<_ScopeModelItem>;
+using TemplateParameterModelItem = std::shared_ptr<_TemplateParameterModelItem>;
+using TypeDefModelItem = std::shared_ptr<_TypeDefModelItem>;
+using TemplateTypeAliasModelItem = std::shared_ptr<_TemplateTypeAliasModelItem>;
+using VariableModelItem = std::shared_ptr<_VariableModelItem>;
+using MemberModelItem = std::shared_ptr<_MemberModelItem>;
 
 using ArgumentList = QList<ArgumentModelItem>;
 using ClassList = QList<ClassModelItem>;
diff --git a/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp b/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp
index 165b52101..3749e16a8 100644
--- a/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp
+++ b/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp
@@ -7,12 +7,34 @@
 #include <QtCore/QString>
 #include <QtCore/QTextStream>
 
+using namespace Qt::StringLiterals;
+
 QString EnumValue::toString() const
 {
     return m_type == EnumValue::Signed
         ? QString::number(m_value) : QString::number(m_unsignedValue);
 }
 
+QString EnumValue::toHex(int fieldWidth) const
+{
+    QString result;
+    QTextStream str(&result);
+    // Note: Qt goofes up formatting of negative padded hex numbers, it ends up
+    // with "0x00-1". Write '-' before.
+    if (isNegative())
+        str << '-';
+    str << "0x" << Qt::hex;
+    if (fieldWidth) {
+        str.setFieldWidth(fieldWidth);
+        str.setPadChar(u'0');
+    }
+    if (m_type == EnumValue::Signed)
+        str << qAbs(m_value);
+    else
+        str << m_unsignedValue;
+    return result;
+}
+
 void EnumValue::setValue(qint64 v)
 {
     m_value = v;
@@ -25,15 +47,33 @@ void EnumValue::setUnsignedValue(quint64 v)
     m_type = Unsigned;
 }
 
-bool EnumValue::equals(const EnumValue &rhs) const
+EnumValue EnumValue::toUnsigned() const
 {
-    if (m_type != rhs.m_type)
+    if (m_type == Unsigned)
+        return *this;
+    EnumValue result;
+    result.setUnsignedValue(m_value < 0 ? quint64(-m_value) : quint64(m_value));
+    return result;
+}
+
+bool comparesEqual(const EnumValue &lhs, const EnumValue &rhs) noexcept
+{
+    if (lhs.m_type != rhs.m_type)
         return false;
-    return m_type == Signed ? m_value == rhs.m_value : m_unsignedValue == rhs.m_unsignedValue;
+    return lhs.m_type == EnumValue::Signed
+        ? lhs.m_value == rhs.m_value : lhs.m_unsignedValue == rhs.m_unsignedValue;
+}
+
+void EnumValue::formatDebugHex(QDebug &d) const
+{
+    d << "0x" << Qt::hex;
+    formatDebug(d);
+    d << Qt::dec;
 }
 
 void EnumValue::formatDebug(QDebug &d) const
 {
+
     if (m_type == EnumValue::Signed)
         d << m_value;
     else
diff --git a/sources/shiboken6/ApiExtractor/parser/enumvalue.h b/sources/shiboken6/ApiExtractor/parser/enumvalue.h
index 3aaed2b73..bbd5a712d 100644
--- a/sources/shiboken6/ApiExtractor/parser/enumvalue.h
+++ b/sources/shiboken6/ApiExtractor/parser/enumvalue.h
@@ -4,7 +4,9 @@
 #ifndef ENUMVALUE_H
 #define ENUMVALUE_H
 
-#include <QtCore/QtGlobal>
+#include <QtCore/qtypes.h>
+#include <QtCore/qtclasshelpermacros.h>
+#include <QtCore/QtCompare>
 
 QT_FORWARD_DECLARE_CLASS(QDebug)
 QT_FORWARD_DECLARE_CLASS(QString)
@@ -20,20 +22,29 @@ public:
     };
 
     QString toString() const;
+    QString toHex(int fieldWidth = 0) const;
 
     Type type() { return m_type; }
     qint64 value() const { return m_value; }
     quint64 unsignedValue() const { return m_unsignedValue; }
     bool isNullValue() const { return m_type == Signed ? m_value == 0 : m_unsignedValue == 0u; }
+    bool isNegative() const { return m_type == Signed && m_value < 0; }
 
     void setValue(qint64 v);
     void setUnsignedValue(quint64 v);
 
+    EnumValue toUnsigned() const;
+
     bool equals(const EnumValue &rhs) const;
 
     void formatDebug(QDebug &d) const;
+    void formatDebugHex(QDebug &d) const;
 
 private:
+    friend bool comparesEqual(const EnumValue &lhs,
+                              const EnumValue &rhs) noexcept;
+    Q_DECLARE_EQUALITY_COMPARABLE(EnumValue)
+
 #ifndef QT_NO_DEBUG_STREAM
     friend QDebug operator<<(QDebug, const EnumValue &);
 #endif
@@ -47,9 +58,4 @@ private:
     Type m_type = Signed;
 };
 
-inline bool operator==(const EnumValue &e1, const EnumValue &e2)
-{ return e1.equals(e2); }
-inline bool operator!=(const EnumValue &e1, const EnumValue &e2)
-{ return !e1.equals(e2); }
-
 #endif // ENUMVALUE_H
diff --git a/sources/shiboken6/ApiExtractor/parser/typeinfo.cpp b/sources/shiboken6/ApiExtractor/parser/typeinfo.cpp
index 205f01de8..f8c5c31d8 100644
--- a/sources/shiboken6/ApiExtractor/parser/typeinfo.cpp
+++ b/sources/shiboken6/ApiExtractor/parser/typeinfo.cpp
@@ -7,6 +7,7 @@
 #include "codemodel.h"
 
 #include <clangparser/clangutils.h>
+#include <debughelpers_p.h>
 
 #include "qtcompat.h"
 
@@ -46,10 +47,10 @@ public:
         };
     };
 
-    ReferenceType m_referenceType;
+    ReferenceType m_referenceType = NoReference;
 };
 
-TypeInfoData::TypeInfoData() : flags(0), m_referenceType(NoReference)
+TypeInfoData::TypeInfoData() : flags(0)
 {
 }
 
@@ -60,9 +61,8 @@ TypeInfo::TypeInfo() : d(new TypeInfoData)
 TypeInfo::~TypeInfo() = default;
 TypeInfo::TypeInfo(const TypeInfo &) = default;
 TypeInfo& TypeInfo::operator=(const TypeInfo &) = default;
-TypeInfo::TypeInfo(TypeInfo &&) = default;
-TypeInfo& TypeInfo::operator=(TypeInfo &&) = default;
-
+TypeInfo::TypeInfo(TypeInfo &&) noexcept = default;
+TypeInfo &TypeInfo::operator=(TypeInfo &&) noexcept = default;
 
 static inline TypeInfo createType(const QString &name)
 {
@@ -98,7 +98,7 @@ TypeInfo TypeInfo::combine(const TypeInfo &__lhs, const TypeInfo &__rhs)
 
     __result.setArrayElements(__result.arrayElements() + __rhs.arrayElements());
 
-    const auto instantiations = __rhs.instantiations();
+    const auto &instantiations = __rhs.instantiations();
     for (const auto &i : instantiations)
         __result.addInstantiation(i);
 
@@ -266,6 +266,12 @@ void TypeInfo::clearInstantiations()
         d->m_instantiations.clear();
 }
 
+bool TypeInfo::isPlain() const
+{
+    return d->m_constant == 0 && d->m_volatile == 0 && d->m_referenceType == NoReference
+        &&  d->m_indirections.isEmpty() && d->m_arrayElements.isEmpty();
+}
+
 TypeInfo TypeInfo::resolveType(TypeInfo const &__type, const ScopeModelItem &__scope)
 {
     CodeModel *__model = __scope->model();
@@ -286,14 +292,14 @@ TypeInfo TypeInfo::resolveType(CodeModelItem __item, TypeInfo const &__type, con
         otherType.setQualifiedName(__item->qualifiedName());
     }
 
-    if (TypeDefModelItem __typedef = qSharedPointerDynamicCast<_TypeDefModelItem>(__item)) {
+    if (TypeDefModelItem __typedef = std::dynamic_pointer_cast<_TypeDefModelItem>(__item)) {
         const TypeInfo combined = TypeInfo::combine(__typedef->type(), otherType);
         const CodeModelItem nextItem = __scope->model()->findItem(combined.qualifiedName(), __scope);
         if (!nextItem)
             return combined;
         // PYSIDE-362, prevent recursion on opaque structs like
         // typedef struct xcb_connection_t xcb_connection_t;
-        if (nextItem.data() ==__item.data()) {
+        if (nextItem.get() ==__item.get()) {
             std::cerr << "** WARNING Bailing out recursion of " << __FUNCTION__
                 << "() on " << qPrintable(__type.qualifiedName().join(u"::"_s))
                 << std::endl;
@@ -302,7 +308,7 @@ TypeInfo TypeInfo::resolveType(CodeModelItem __item, TypeInfo const &__type, con
         return resolveType(nextItem, combined, __scope);
     }
 
-    if (TemplateTypeAliasModelItem templateTypeAlias = qSharedPointerDynamicCast<_TemplateTypeAliasModelItem>(__item)) {
+    if (TemplateTypeAliasModelItem templateTypeAlias = std::dynamic_pointer_cast<_TemplateTypeAliasModelItem>(__item)) {
 
         TypeInfo combined = TypeInfo::combine(templateTypeAlias->type(), otherType);
         // For the alias "template<typename T> using QList = QVector<T>" with
@@ -313,7 +319,7 @@ TypeInfo TypeInfo::resolveType(CodeModelItem __item, TypeInfo const &__type, con
         for (qsizetype i = 0; i < count; ++i)
             aliasInstantiations[i] = concreteInstantiations.at(i);
         combined.setInstantiations(aliasInstantiations);
-        const CodeModelItem nextItem = __scope->model()->findItem(combined.qualifiedName(), __scope);
+        const CodeModelItem nextItem = CodeModel::findItem(combined.qualifiedName(), __scope);
         if (!nextItem)
             return combined;
         return resolveType(nextItem, combined, __scope);
@@ -341,6 +347,10 @@ public:
         while (level < m_parseStack.size())
             m_parseStack.pop();
         TypeInfo instantiation;
+        if (name.startsWith(u"const ")) {
+            instantiation.setConstant(true);
+            name = name.mid(6);
+        }
         instantiation.setQualifiedName(qualifiedName(name));
         top()->addInstantiation(instantiation);
    }
@@ -361,7 +371,8 @@ private:
     QStack<TypeInfo *> m_parseStack;
 };
 
-QPair<qsizetype, qsizetype> TypeInfo::parseTemplateArgumentList(const QString &l, qsizetype from)
+std::pair<qsizetype, qsizetype>
+    TypeInfo::parseTemplateArgumentList(const QString &l, qsizetype from)
 {
     return clang::parseTemplateArgumentList(l, clang::TemplateArgumentHandler(TypeInfoTemplateArgumentHandler(this)), from);
 }
@@ -441,31 +452,28 @@ bool TypeInfoData::equals(const TypeInfoData &other) const
            && m_instantiations == other.m_instantiations;
 }
 
-bool TypeInfo::equals(const TypeInfo &other) const
+
+bool comparesEqual(const TypeInfo &lhs, const TypeInfo &rhs) noexcept
 {
-    return d.data() == other.d.data() || d->equals(*other.d);
+   return lhs.d.data() == rhs.d.data() || lhs.d->equals(*rhs.d);
 }
 
 QString TypeInfo::indirectionKeyword(Indirection i)
 {
-    return i == Indirection::Pointer
-        ? QStringLiteral("*") : QStringLiteral("*const");
+    return i == Indirection::Pointer ? "*"_L1 : "*const"_L1;
 }
 
-static inline QString constQualifier() { return QStringLiteral("const"); }
-static inline QString volatileQualifier() { return QStringLiteral("volatile"); }
-
 bool TypeInfo::stripLeadingConst(QString *s)
 {
-    return stripLeadingQualifier(constQualifier(), s);
+    return stripLeadingQualifier("const"_L1, s);
 }
 
 bool TypeInfo::stripLeadingVolatile(QString *s)
 {
-    return stripLeadingQualifier(volatileQualifier(), s);
+    return stripLeadingQualifier("volatile"_L1, s);
 }
 
-bool TypeInfo::stripLeadingQualifier(const QString &qualifier, QString *s)
+bool TypeInfo::stripLeadingQualifier(QLatin1StringView qualifier, QString *s)
 {
     // "const int x"
     const auto qualifierSize = qualifier.size();
@@ -558,16 +566,6 @@ void TypeInfo::formatTypeSystemSignature(QTextStream &str) const
 }
 
 #ifndef QT_NO_DEBUG_STREAM
-template <class It>
-void formatSequence(QDebug &d, It i1, It i2, const char *separator=", ")
-{
-    for (It i = i1; i != i2; ++i) {
-        if (i != i1)
-            d << separator;
-        d << *i;
-    }
-}
-
 void TypeInfo::formatDebug(QDebug &debug) const
 {
     debug << '"';
diff --git a/sources/shiboken6/ApiExtractor/parser/typeinfo.h b/sources/shiboken6/ApiExtractor/parser/typeinfo.h
index cf3576eb6..e4f363b67 100644
--- a/sources/shiboken6/ApiExtractor/parser/typeinfo.h
+++ b/sources/shiboken6/ApiExtractor/parser/typeinfo.h
@@ -10,8 +10,11 @@
 
 #include <QtCore/QString>
 #include <QtCore/QSharedDataPointer>
+#include <QtCore/QtCompare>
 #include <QtCore/QStringList>
 
+#include <utility>
+
 QT_FORWARD_DECLARE_CLASS(QDebug)
 QT_FORWARD_DECLARE_CLASS(QTextStream)
 
@@ -28,8 +31,8 @@ public:
     ~TypeInfo();
     TypeInfo(const TypeInfo &);
     TypeInfo& operator=(const TypeInfo &);
-    TypeInfo(TypeInfo &&);
-    TypeInfo& operator=(TypeInfo &&);
+    TypeInfo(TypeInfo &&) noexcept;
+    TypeInfo &operator=(TypeInfo &&) noexcept;
 
     static TypeInfo voidType();
     static TypeInfo varArgsType();
@@ -77,11 +80,12 @@ public:
     void addInstantiation(const TypeInfo &i);
     void clearInstantiations();
 
-    bool isStdType() const;
+    bool isPlain() const; // neither const,volatile, no indirections/references, array
 
-    QPair<qsizetype, qsizetype> parseTemplateArgumentList(const QString &l, qsizetype from = 0);
+    bool isStdType() const;
 
-    bool equals(const TypeInfo &other) const;
+    std::pair<qsizetype, qsizetype>
+        parseTemplateArgumentList(const QString &l, qsizetype from = 0);
 
     // ### arrays and templates??
 
@@ -100,12 +104,16 @@ public:
 
     static bool stripLeadingConst(QString *s);
     static bool stripLeadingVolatile(QString *s);
-    static bool stripLeadingQualifier(const QString &qualifier, QString *s);
+    static bool stripLeadingQualifier(QLatin1StringView qualifier, QString *s);
     static void stripQualifiers(QString *s);
 
     void simplifyStdType();
 
 private:
+    friend bool comparesEqual(const TypeInfo &lhs,
+                              const TypeInfo &rhs) noexcept;
+    Q_DECLARE_EQUALITY_COMPARABLE(TypeInfo)
+
     QSharedDataPointer<TypeInfoData> d;
 
     friend class TypeInfoTemplateArgumentHandler;
@@ -113,12 +121,6 @@ private:
     static TypeInfo resolveType(CodeModelItem item, TypeInfo const &__type, const ScopeModelItem &__scope);
 };
 
-inline bool operator==(const TypeInfo &t1, const TypeInfo &t2)
-{ return t1.equals(t2); }
-
-inline bool operator!=(const TypeInfo &t1, const TypeInfo &t2)
-{ return !t1.equals(t2); }
-
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug d, const TypeInfo &t);
 #endif
diff --git a/sources/shiboken6/ApiExtractor/predefined_templates.cpp b/sources/shiboken6/ApiExtractor/predefined_templates.cpp
index be3dd9319..992f735ac 100644
--- a/sources/shiboken6/ApiExtractor/predefined_templates.cpp
+++ b/sources/shiboken6/ApiExtractor/predefined_templates.cpp
@@ -39,20 +39,37 @@ while (true) {
     return result;
 }
 
-static const char stlMapKeyAccessor[] = "->first";
-static const char stlMapValueAccessor[] = "->second";
-static const char qtMapKeyAccessor[] = ".key()";
-static const char qtMapValueAccessor[] = ".value()";
+// Convert a sequence to a limited/fixed array
+static QString pySequenceToCppArray()
+{
+    return uR"(Shiboken::AutoDecRef it(PyObject_GetIter(%in));
+for (auto oit = std::begin(%out), oend = std::end(%out); oit != oend; ++oit) {
+    Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
+    if (pyItem.isNull()) {
+        if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
+            PyErr_Clear();
+        break;
+    }
+    %OUTTYPE_0 cppItem = %CONVERTTOCPP[%OUTTYPE_0](pyItem);
+    *oit = cppItem;
+}
+)"_s;
+}
+
+static constexpr auto stlMapKeyAccessor = "->first"_L1;
+static constexpr auto stlMapValueAccessor = "->second"_L1;
+static constexpr auto qtMapKeyAccessor = ".key()"_L1;
+static constexpr auto qtMapValueAccessor = ".value()"_L1;
 
 static QString cppMapToPyDict(bool isQMap)
 {
     return uR"(PyObject *%out = PyDict_New();
-for (auto it = %in.cbegin(), end = %in.cend(); it != end; ++it) {
+for (auto it = std::cbegin(%in), end = std::cend(%in); it != end; ++it) {
     const auto &key = it)"_s
-        + QLatin1StringView(isQMap ? qtMapKeyAccessor : stlMapKeyAccessor)
+        + (isQMap ? qtMapKeyAccessor : stlMapKeyAccessor)
         + uR"(;
     const auto &value = it)"_s
-        + QLatin1StringView(isQMap ? qtMapValueAccessor : stlMapValueAccessor)
+        + (isQMap ? qtMapValueAccessor : stlMapValueAccessor)
         + uR"(;
     PyObject *pyKey = %CONVERTTOPYTHON[%INTYPE_0](key);
     PyObject *pyValue = %CONVERTTOPYTHON[%INTYPE_1](value);
@@ -84,9 +101,9 @@ while (PyDict_Next(%in, &pos, &key, &value)) {
 static QString cppMultiMapToPyDict(bool isQMultiMap)
 {
     return uR"(PyObject *%out = PyDict_New();
-    for (auto it = %in.cbegin(), end = %in.cend(); it != end; ) {
+    for (auto it = std::cbegin(%in), end = std::cend(%in); it != end; ) {
         const auto &key = it)"_s
-        + QLatin1StringView(isQMultiMap ? qtMapKeyAccessor : stlMapKeyAccessor)
+        + (isQMultiMap ? qtMapKeyAccessor : stlMapKeyAccessor)
         + uR"(;
         PyObject *pyKey = %CONVERTTOPYTHON[%INTYPE_0](key);
         auto upper = %in.)"_s
@@ -110,9 +127,9 @@ static QString cppMultiMapToPyDict(bool isQMultiMap)
 static QString cppMultiHashToPyDict(bool isQMultiHash)
 {
     return uR"(PyObject *%out = PyDict_New();
-    for (auto it = %in.cbegin(), end = %in.cend(); it != end; ) {
+    for (auto it = std::cbegin(%in), end = std::cend(%in); it != end; ) {
         const auto &key = it)"_s
-           +  QLatin1StringView(isQMultiHash ? qtMapKeyAccessor : stlMapKeyAccessor)
+           + (isQMultiHash ? qtMapKeyAccessor : stlMapKeyAccessor)
            + uR"(;
         PyObject *pyKey = %CONVERTTOPYTHON[%INTYPE_0](key);
         auto range = %in.equal_range(key);
@@ -174,7 +191,7 @@ return %out;
     {u"shiboken_conversion_cppsequence_to_pylist"_s,
      uR"(PyObject *%out = PyList_New(Py_ssize_t(%in.size()));
 Py_ssize_t idx = 0;
-for (auto it = %in.cbegin(), end = %in.cend(); it != end; ++it, ++idx) {
+for (auto it = std::cbegin(%in), end = std::cend(%in); it != end; ++it, ++idx) {
     const auto &cppItem = *it;
     PyList_SET_ITEM(%out, idx, %CONVERTTOPYTHON[%INTYPE_0](cppItem));
 }
@@ -192,6 +209,8 @@ return %out;)"_s},
      pySequenceToCppContainer(u"push_back"_s, false)},
     {u"shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve"_s,
      pySequenceToCppContainer(u"push_back"_s, true)},
+    {u"shiboken_conversion_pyiterable_to_cpparray"_s,
+     pySequenceToCppArray()},
     {u"shiboken_conversion_pyiterable_to_cppsetcontainer"_s,
      pySequenceToCppContainer(u"insert"_s, false)},
 
@@ -233,19 +252,25 @@ QByteArray containerTypeSystemSnippet(const char *name, const char *type,
                                       const char *targetToNativeType,
                                       const char *targetToNative)
 {
-    return QByteArrayLiteral("<container-type name=\"")
+    QByteArray result = QByteArrayLiteral("<container-type name=\"")
             + name + QByteArrayLiteral("\" type=\"") + type + R"(">
     <include file-name=")" + include + R"(" location="global"/>
     <conversion-rule>
         <native-to-target>
             <insert-template name=")" + nativeToTarget + R"("/>
         </native-to-target>
-        <target-to-native>
-            <add-conversion type=")" + targetToNativeType + R"(">
-                <insert-template name=")" + targetToNative + R"("/>
+)";
+    if (targetToNativeType != nullptr) {
+        result += QByteArrayLiteral(R"(        <target-to-native>
+            <add-conversion type=")") + targetToNativeType
+                + QByteArrayLiteral(R"(">
+                <insert-template name=")") + targetToNative + QByteArrayLiteral(R"("/>
             </add-conversion>
         </target-to-native>
-    </conversion-rule>
+)");
+        }
+result += QByteArrayLiteral(R"(    </conversion-rule>
 </container-type>
-)";
+)");
+    return result;
 }
diff --git a/sources/shiboken6/ApiExtractor/predefined_templates.h b/sources/shiboken6/ApiExtractor/predefined_templates.h
index 2519f65d9..0cc2c7f32 100644
--- a/sources/shiboken6/ApiExtractor/predefined_templates.h
+++ b/sources/shiboken6/ApiExtractor/predefined_templates.h
@@ -21,7 +21,7 @@ const PredefinedTemplates &predefinedTemplates();
 QByteArray containerTypeSystemSnippet(const char *name, const char *type,
                                       const char *include,
                                       const char *nativeToTarget,
-                                      const char *targetToNativeType,
-                                      const char *targetToNative);
+                                      const char *targetToNativeType = nullptr,
+                                      const char *targetToNative = nullptr);
 
 #endif // PREDEFINED_TEMPLATES_H
diff --git a/sources/shiboken6/ApiExtractor/propertyspec.cpp b/sources/shiboken6/ApiExtractor/propertyspec.cpp
index 1c86cacf6..32b756fad 100644
--- a/sources/shiboken6/ApiExtractor/propertyspec.cpp
+++ b/sources/shiboken6/ApiExtractor/propertyspec.cpp
@@ -59,8 +59,8 @@ QPropertySpec::QPropertySpec(const TypeSystemProperty &ts,
 
 QPropertySpec::QPropertySpec(const QPropertySpec &) = default;
 QPropertySpec &QPropertySpec::operator=(const QPropertySpec &) = default;
-QPropertySpec::QPropertySpec(QPropertySpec &&) = default;
-QPropertySpec &QPropertySpec::operator=(QPropertySpec &&) = default;
+QPropertySpec::QPropertySpec(QPropertySpec &&) noexcept = default;
+QPropertySpec &QPropertySpec::operator=(QPropertySpec &&) noexcept = default;
 QPropertySpec::~QPropertySpec() = default;
 
 const AbstractMetaType &QPropertySpec::type() const
@@ -189,14 +189,15 @@ void QPropertySpec::setGenerateGetSetDef(bool generateGetSetDef)
 TypeSystemProperty QPropertySpec::typeSystemPropertyFromQ_Property(const QString &declarationIn,
                                                                    QString *errorMessage)
 {
-    enum class PropertyToken { None, Read, Write, Designable, Reset, Notify };
+    enum class PropertyToken { None, Read, Write, Designable, Reset, Notify, Member };
 
     static const QHash<QString, PropertyToken> tokenLookup = {
-        {QStringLiteral("READ"), PropertyToken::Read},
-        {QStringLiteral("WRITE"), PropertyToken::Write},
-        {QStringLiteral("DESIGNABLE"), PropertyToken::Designable},
-        {QStringLiteral("RESET"), PropertyToken::Reset},
-        {QStringLiteral("NOTIFY"), PropertyToken::Notify}
+        {"READ"_L1, PropertyToken::Read},
+        {"WRITE"_L1, PropertyToken::Write},
+        {"DESIGNABLE"_L1, PropertyToken::Designable},
+        {"RESET"_L1, PropertyToken::Reset},
+        {"NOTIFY"_L1, PropertyToken::Notify},
+        {"MEMBER"_L1, PropertyToken::Member}
     };
 
     errorMessage->clear();
@@ -242,17 +243,21 @@ TypeSystemProperty QPropertySpec::typeSystemPropertyFromQ_Property(const QString
         case PropertyToken::Notify:
             result.notify = propertyTokens.at(pos + 1);
             break;
+        case PropertyToken::Member:
+            // Ignore MEMBER tokens introduced by QTBUG-16852 as Python
+            // properties are anyways generated for fields.
+            return {};
 
         case PropertyToken::None:
             break;
         }
     }
 
-    const int namePos = firstToken - 1;
+    const auto namePos = firstToken - 1;
     result.name = propertyTokens.at(namePos);
 
     result.type = propertyTokens.constFirst();
-    for (int pos = 1; pos < namePos; ++pos)
+    for (qsizetype pos = 1; pos < namePos; ++pos)
         result.type += u' ' + propertyTokens.at(pos);
 
     // Fix errors like "Q_PROPERTY(QXYSeries *series .." to be of type "QXYSeries*"
@@ -269,7 +274,7 @@ TypeSystemProperty QPropertySpec::typeSystemPropertyFromQ_Property(const QString
 // the AbstractMetaType from the type string.
 std::optional<QPropertySpec>
     QPropertySpec::fromTypeSystemProperty(AbstractMetaBuilderPrivate *b,
-                                          AbstractMetaClass *metaClass,
+                                          const AbstractMetaClassPtr &metaClass,
                                           const TypeSystemProperty &ts,
                                           const QStringList &scopes,
                                           QString *errorMessage)
@@ -302,7 +307,7 @@ std::optional<QPropertySpec>
 // via TypeSystemProperty.
 std::optional<QPropertySpec>
     QPropertySpec::parseQ_Property(AbstractMetaBuilderPrivate *b,
-                                   AbstractMetaClass *metaClass,
+                                   const AbstractMetaClassPtr &metaClass,
                                    const QString &declarationIn,
                                    const QStringList &scopes,
                                    QString *errorMessage)
diff --git a/sources/shiboken6/ApiExtractor/propertyspec.h b/sources/shiboken6/ApiExtractor/propertyspec.h
index 907668cb1..9e2e0f3d4 100644
--- a/sources/shiboken6/ApiExtractor/propertyspec.h
+++ b/sources/shiboken6/ApiExtractor/propertyspec.h
@@ -6,6 +6,7 @@
 
 class AbstractMetaType;
 
+#include "abstractmetalang_typedefs.h"
 #include "typesystem_typedefs.h"
 
 #include <QtCore/QStringList>
@@ -32,8 +33,8 @@ public:
                            const AbstractMetaType &type);
     QPropertySpec(const QPropertySpec &);
     QPropertySpec &operator=(const QPropertySpec &);
-    QPropertySpec(QPropertySpec &&);
-    QPropertySpec &operator=(QPropertySpec &&);
+    QPropertySpec(QPropertySpec &&) noexcept;
+    QPropertySpec &operator=(QPropertySpec &&) noexcept;
     ~QPropertySpec();
 
     static TypeSystemProperty typeSystemPropertyFromQ_Property(const QString &declarationIn,
@@ -42,14 +43,14 @@ public:
 
     static std::optional<QPropertySpec>
         fromTypeSystemProperty(AbstractMetaBuilderPrivate *b,
-                               AbstractMetaClass *metaClass,
+                               const AbstractMetaClassPtr &metaClass,
                                const TypeSystemProperty &ts,
                                const QStringList &scopes,
                                QString *errorMessage);
 
     static std::optional<QPropertySpec>
         parseQ_Property(AbstractMetaBuilderPrivate *b,
-                        AbstractMetaClass *metaClass,
+                        const AbstractMetaClassPtr &metaClass,
                         const QString &declarationIn,
                         const QStringList &scopes,
                         QString *errorMessage);
diff --git a/sources/shiboken6/ApiExtractor/pymethoddefentry.cpp b/sources/shiboken6/ApiExtractor/pymethoddefentry.cpp
index 75ac227b8..64d44378b 100644
--- a/sources/shiboken6/ApiExtractor/pymethoddefentry.cpp
+++ b/sources/shiboken6/ApiExtractor/pymethoddefentry.cpp
@@ -6,10 +6,15 @@
 
 #include <QtCore/QDebug>
 
+TextStream &operator<<(TextStream &str, const castToPyCFunction &c)
+{
+    str << "reinterpret_cast<PyCFunction>(" << c.m_function << ')';
+    return str;
+}
+
 TextStream &operator<<(TextStream &s, const PyMethodDefEntry &e)
 {
-     s <<  "{\"" << e.name << "\", reinterpret_cast<PyCFunction>("
-      << e.function << "), ";
+    s <<  "{\"" << e.name << "\", " << castToPyCFunction(e.function) <<", ";
     if (e.methFlags.isEmpty()) {
          s << '0';
     } else {
diff --git a/sources/shiboken6/ApiExtractor/pymethoddefentry.h b/sources/shiboken6/ApiExtractor/pymethoddefentry.h
index 54eaa4ce1..a8694eb30 100644
--- a/sources/shiboken6/ApiExtractor/pymethoddefentry.h
+++ b/sources/shiboken6/ApiExtractor/pymethoddefentry.h
@@ -11,6 +11,14 @@ QT_FORWARD_DECLARE_CLASS(QDebug)
 
 class TextStream;
 
+struct castToPyCFunction
+{
+    explicit castToPyCFunction(QAnyStringView function) noexcept :
+        m_function(function) {}
+
+    QAnyStringView m_function;
+};
+
 struct PyMethodDefEntry
 {
     QString name;
@@ -21,6 +29,7 @@ struct PyMethodDefEntry
 
 using PyMethodDefEntries = QList<PyMethodDefEntry>;
 
+TextStream &operator<<(TextStream &str, const castToPyCFunction &e);
 TextStream &operator<<(TextStream &s, const PyMethodDefEntry &e);
 TextStream &operator<<(TextStream &s, const PyMethodDefEntries &e);
 
diff --git a/sources/shiboken6/ApiExtractor/qtcompat.h b/sources/shiboken6/ApiExtractor/qtcompat.h
index 9627bb76c..3837dcfd2 100644
--- a/sources/shiboken6/ApiExtractor/qtcompat.h
+++ b/sources/shiboken6/ApiExtractor/qtcompat.h
@@ -4,7 +4,7 @@
 #ifndef QTCOMPAT_H
 #define QTCOMPAT_H
 
-#include <QtCore/QtGlobal>
+#include <QtCore/qtconfigmacros.h>
 
 #if QT_VERSION < 0x060400
 
diff --git a/sources/shiboken6/ApiExtractor/qtdocparser.cpp b/sources/shiboken6/ApiExtractor/qtdocparser.cpp
index 8daf1ad85..5bd99bbd8 100644
--- a/sources/shiboken6/ApiExtractor/qtdocparser.cpp
+++ b/sources/shiboken6/ApiExtractor/qtdocparser.cpp
@@ -15,6 +15,8 @@
 #include "reporthandler.h"
 #include "flagstypeentry.h"
 #include "complextypeentry.h"
+#include "functiontypeentry.h"
+#include "enumtypeentry.h"
 
 #include "qtcompat.h"
 
@@ -26,8 +28,9 @@ using namespace Qt::StringLiterals;
 
 enum { debugFunctionSearch = 0 };
 
-static inline QString briefStartElement() { return QStringLiteral("<brief>"); }
-static inline QString briefEndElement() { return QStringLiteral("</brief>"); }
+constexpr auto briefStartElement = "<brief>"_L1;
+constexpr auto briefEndElement = "</brief>"_L1;
+constexpr auto webxmlSuffix = ".webxml"_L1;
 
 Documentation QtDocParser::retrieveModuleDocumentation()
 {
@@ -57,7 +60,7 @@ static void formatFunctionUnqualifiedArgTypeQuery(QTextStream &str,
     case AbstractMetaType::FlagsPattern: {
         // Modify qualified name "QFlags<Qt::AlignmentFlag>" with name "Alignment"
         // to "Qt::Alignment" as seen by qdoc.
-        const auto flagsEntry = qSharedPointerCast<const FlagsTypeEntry>(metaType.typeEntry());
+        const auto flagsEntry = std::static_pointer_cast<const FlagsTypeEntry>(metaType.typeEntry());
         QString name = flagsEntry->qualifiedCppName();
         if (name.endsWith(u'>') && name.startsWith(u"QFlags<")) {
             const int lastColon = name.lastIndexOf(u':');
@@ -102,7 +105,7 @@ static QString formatFunctionArgTypeQuery(const AbstractMetaType &metaType)
 
 QString QtDocParser::functionDocumentation(const QString &sourceFileName,
                                            const ClassDocumentation &classDocumentation,
-                                           const AbstractMetaClass *metaClass,
+                                           const AbstractMetaClassCPtr &metaClass,
                                            const AbstractMetaFunctionCPtr &func,
                                            QString *errorMessage)
 {
@@ -112,14 +115,14 @@ QString QtDocParser::functionDocumentation(const QString &sourceFileName,
         queryFunctionDocumentation(sourceFileName, classDocumentation, metaClass,
                                    func, errorMessage);
 
-    const auto funcModifs = DocParser::getDocModifications(metaClass, func);
+    const auto funcModifs = DocParser::getXpathDocModifications(func, metaClass);
     return docString.isEmpty() || funcModifs.isEmpty()
         ? docString : applyDocModifications(funcModifs, docString);
 }
 
 QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName,
                                                 const ClassDocumentation &classDocumentation,
-                                                const AbstractMetaClass *metaClass,
+                                                const AbstractMetaClassCPtr &metaClass,
                                                 const AbstractMetaFunctionCPtr &func,
                                                 QString *errorMessage)
 {
@@ -127,7 +130,7 @@ QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName,
     FunctionDocumentationList candidates =
         classDocumentation.findFunctionCandidates(func->name(), func->isConstant());
     if (candidates.isEmpty()) {
-        *errorMessage = msgCannotFindDocumentation(sourceFileName, func.data())
+        *errorMessage = msgCannotFindDocumentation(sourceFileName, func.get())
                         + u" (no matches)"_s;
         return {};
     }
@@ -172,13 +175,13 @@ QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName,
     candidates.erase(pend, candidates.end());
     if (candidates.size() == 1) {
         const auto &match = candidates.constFirst();
-        QTextStream(errorMessage) << msgFallbackForDocumentation(sourceFileName, func.data())
+        QTextStream(errorMessage) << msgFallbackForDocumentation(sourceFileName, func.get())
             << "\n  Falling back to \"" << match.signature
             << "\" obtained by matching the argument count only.";
         return candidates.constFirst().description;
     }
 
-    QTextStream(errorMessage) << msgCannotFindDocumentation(sourceFileName, func.data())
+    QTextStream(errorMessage) << msgCannotFindDocumentation(sourceFileName, func.get())
         << " (" << candidates.size() << " candidates matching the argument count)";
     return {};
 }
@@ -187,29 +190,100 @@ QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName,
 // from the source.
 static QString extractBrief(QString *value)
 {
-    const auto briefStart = value->indexOf(briefStartElement());
+    const auto briefStart = value->indexOf(briefStartElement);
     if (briefStart < 0)
         return {};
-    const auto briefEnd = value->indexOf(briefEndElement(),
-                                         briefStart + briefStartElement().size());
+    const auto briefEnd = value->indexOf(briefEndElement,
+                                         briefStart + briefStartElement.size());
     if (briefEnd < briefStart)
         return {};
-    const auto briefLength = briefEnd + briefEndElement().size() - briefStart;
+    const auto briefLength = briefEnd + briefEndElement.size() - briefStart;
     QString briefValue = value->mid(briefStart, briefLength);
-    briefValue.insert(briefValue.size() - briefEndElement().size(),
+    briefValue.insert(briefValue.size() - briefEndElement.size(),
                       u"<rst> More_...</rst>"_s);
     value->remove(briefStart, briefLength);
     return briefValue;
 }
 
-void QtDocParser::fillDocumentation(AbstractMetaClass *metaClass)
+// Find the webxml file for global functions/enums
+// by the doc-file typesystem attribute or via include file.
+static QString findGlobalWebXmLFile(const QString &documentationDataDirectory,
+                                    const QString &docFile,
+                                    const Include &include)
+{
+    QString result;
+    if (!docFile.isEmpty()) {
+        result = documentationDataDirectory + u'/' + docFile;
+        if (!result.endsWith(webxmlSuffix))
+            result += webxmlSuffix;
+        return QFileInfo::exists(result) ? result : QString{};
+    }
+    if (include.name().isEmpty())
+        return {};
+    // qdoc "\headerfile <QtLogging>" directive produces "qtlogging.webxml"
+    result = documentationDataDirectory + u'/' +
+             QFileInfo(include.name()).baseName() + webxmlSuffix;
+    if (QFileInfo::exists(result))
+        return result;
+    // qdoc "\headerfile <qdrawutil.h>" produces "qdrawutil-h.webxml"
+    result.insert(result.size() - webxmlSuffix.size(), "-h"_L1);
+    return QFileInfo::exists(result) ? result : QString{};
+}
+
+void  QtDocParser::fillGlobalFunctionDocumentation(const AbstractMetaFunctionPtr &f)
+{
+    auto te = f->typeEntry();
+    if (te == nullptr)
+        return;
+
+    const QString sourceFileName =
+        findGlobalWebXmLFile(documentationDataDirectory(), te->docFile(), te->include());
+    if (sourceFileName.isEmpty())
+        return;
+
+    QString errorMessage;
+    auto classDocumentationO = parseWebXml(sourceFileName, &errorMessage);
+    if (!classDocumentationO.has_value()) {
+        qCWarning(lcShibokenDoc, "%s", qPrintable(errorMessage));
+        return;
+    }
+    const QString detailed =
+        functionDocumentation(sourceFileName, classDocumentationO.value(),
+                              {}, f, &errorMessage);
+    if (!errorMessage.isEmpty())
+        qCWarning(lcShibokenDoc, "%s", qPrintable(errorMessage));
+    const Documentation documentation(detailed, {});
+    f->setDocumentation(documentation);
+}
+
+void QtDocParser::fillGlobalEnumDocumentation(AbstractMetaEnum &e)
+{
+    auto te = e.typeEntry();
+    const QString sourceFileName =
+        findGlobalWebXmLFile(documentationDataDirectory(), te->docFile(), te->include());
+    if (sourceFileName.isEmpty())
+        return;
+
+    QString errorMessage;
+    auto classDocumentationO = parseWebXml(sourceFileName, &errorMessage);
+    if (!classDocumentationO.has_value()) {
+        qCWarning(lcShibokenDoc, "%s", qPrintable(errorMessage));
+        return;
+    }
+    if (!extractEnumDocumentation(classDocumentationO.value(), e)) {
+        qCWarning(lcShibokenDoc, "%s",
+                  qPrintable(msgCannotFindDocumentation(sourceFileName, {}, e, {})));
+    }
+}
+
+void QtDocParser::fillDocumentation(const AbstractMetaClassPtr &metaClass)
 {
     if (!metaClass)
         return;
 
-    auto *context = metaClass->enclosingClass();
-    while(context) {
-        if (context->enclosingClass() == nullptr)
+    auto context = metaClass->enclosingClass();
+    while (context) {
+        if (!context->enclosingClass())
             break;
         context = context->enclosingClass();
     }
@@ -218,9 +292,9 @@ void QtDocParser::fillDocumentation(AbstractMetaClass *metaClass)
         + metaClass->qualifiedCppName().toLower();
     sourceFileRoot.replace(u"::"_s, u"-"_s);
 
-    QFileInfo sourceFile(sourceFileRoot + QStringLiteral(".webxml"));
+    QFileInfo sourceFile(sourceFileRoot + webxmlSuffix);
     if (!sourceFile.exists())
-        sourceFile.setFile(sourceFileRoot + QStringLiteral(".xml"));
+        sourceFile.setFile(sourceFileRoot + ".xml"_L1);
    if (!sourceFile.exists()) {
         qCWarning(lcShibokenDoc).noquote().nospace()
             << "Can't find qdoc file for class " << metaClass->name() << ", tried: "
@@ -231,18 +305,19 @@ void QtDocParser::fillDocumentation(AbstractMetaClass *metaClass)
     const QString sourceFileName = sourceFile.absoluteFilePath();
     QString errorMessage;
 
-    const ClassDocumentation classDocumentation = parseWebXml(sourceFileName, &errorMessage);
-    if (!classDocumentation) {
+    const auto classDocumentationO = parseWebXml(sourceFileName, &errorMessage);
+    if (!classDocumentationO.has_value()) {
         qCWarning(lcShibokenDoc, "%s", qPrintable(errorMessage));
         return;
     }
 
+    const auto &classDocumentation = classDocumentationO.value();
     for (const auto &p : classDocumentation.properties) {
         Documentation doc(p.description, p.brief);
         metaClass->setPropertyDocumentation(p.name, doc);
     }
 
-    QString docString = applyDocModifications(metaClass->typeEntry()->docModifications(),
+    QString docString = applyDocModifications(DocParser::getXpathDocModifications(metaClass),
                                               classDocumentation.description);
 
     if (docString.isEmpty()) {
@@ -267,7 +342,7 @@ void QtDocParser::fillDocumentation(AbstractMetaClass *metaClass)
         if (!errorMessage.isEmpty())
             qCWarning(lcShibokenDoc, "%s", qPrintable(errorMessage));
         const Documentation documentation(detailed, {});
-        qSharedPointerConstCast<AbstractMetaFunction>(func)->setDocumentation(documentation);
+        std::const_pointer_cast<AbstractMetaFunction>(func)->setDocumentation(documentation);
     }
 #if 0
     // Fields
@@ -283,28 +358,35 @@ void QtDocParser::fillDocumentation(AbstractMetaClass *metaClass)
 #endif
     // Enums
     for (AbstractMetaEnum &meta_enum : metaClass->enums()) {
-        Documentation enumDoc;
-        const auto index = classDocumentation.indexOfEnum(meta_enum.name());
-        if (index != -1) {
-            QString doc = classDocumentation.enums.at(index).description;
-            const auto firstPara = doc.indexOf(u"<para>");
-            if (firstPara != -1) {
-                const QString baseClass = QtDocParser::enumBaseClass(meta_enum);
-                if (baseClass != u"Enum") {
-                    const QString note = u"(inherits <teletype>enum."_s + baseClass
-                                         + u"</teletype>) "_s;
-                    doc.insert(firstPara + 6, note);
-                }
-            }
-            enumDoc.setValue(doc);
-            meta_enum.setDocumentation(enumDoc);
-        } else {
+        if (!extractEnumDocumentation(classDocumentation, meta_enum)) {
             qCWarning(lcShibokenDoc, "%s",
                       qPrintable(msgCannotFindDocumentation(sourceFileName, metaClass, meta_enum, {})));
         }
     }
 }
 
+bool QtDocParser::extractEnumDocumentation(const ClassDocumentation &classDocumentation,
+                                           AbstractMetaEnum &meta_enum)
+{
+    Documentation enumDoc;
+    const auto index = classDocumentation.indexOfEnum(meta_enum.name());
+    if (index == -1)
+        return false;
+    QString doc = classDocumentation.enums.at(index).description;
+    const auto firstPara = doc.indexOf(u"<para>");
+    if (firstPara != -1) {
+        const QString baseClass = QtDocParser::enumBaseClass(meta_enum);
+        if (baseClass != "Enum"_L1) {
+            const QString note = "(inherits <teletype>enum."_L1 + baseClass
+                                 + "</teletype>) "_L1;
+            doc.insert(firstPara + 6, note);
+        }
+    }
+    enumDoc.setValue(doc);
+    meta_enum.setDocumentation(enumDoc);
+    return true;
+}
+
 static QString qmlReferenceLink(const QFileInfo &qmlModuleFi)
 {
     QString result;
diff --git a/sources/shiboken6/ApiExtractor/qtdocparser.h b/sources/shiboken6/ApiExtractor/qtdocparser.h
index 402664217..f6ba5e47a 100644
--- a/sources/shiboken6/ApiExtractor/qtdocparser.h
+++ b/sources/shiboken6/ApiExtractor/qtdocparser.h
@@ -12,22 +12,28 @@ class QtDocParser : public DocParser
 {
 public:
     QtDocParser() = default;
-    void fillDocumentation(AbstractMetaClass *metaClass) override;
+    void fillDocumentation(const AbstractMetaClassPtr &metaClass) override;
+    void fillGlobalFunctionDocumentation(const AbstractMetaFunctionPtr &f) override;
+    void fillGlobalEnumDocumentation(AbstractMetaEnum &e) override;
+
     Documentation retrieveModuleDocumentation() override;
     Documentation retrieveModuleDocumentation(const QString& name) override;
 
 private:
     static QString functionDocumentation(const QString &sourceFileName,
                                          const ClassDocumentation &classDocumentation,
-                                         const AbstractMetaClass *metaClass,
+                                         const AbstractMetaClassCPtr &metaClass,
                                          const AbstractMetaFunctionCPtr &func,
                                          QString *errorMessage);
 
     static QString queryFunctionDocumentation(const QString &sourceFileName,
                                               const ClassDocumentation &classDocumentation,
-                                              const AbstractMetaClass *metaClass,
+                                              const AbstractMetaClassCPtr &metaClass,
                                               const AbstractMetaFunctionCPtr &func,
                                               QString *errorMessage);
+    static bool extractEnumDocumentation(const ClassDocumentation &classDocumentation,
+                                         AbstractMetaEnum &meta_enum);
+
 };
 
 #endif // QTDOCPARSER_H
diff --git a/sources/shiboken6/ApiExtractor/reporthandler.cpp b/sources/shiboken6/ApiExtractor/reporthandler.cpp
index 2fc7b47b7..23066ba21 100644
--- a/sources/shiboken6/ApiExtractor/reporthandler.cpp
+++ b/sources/shiboken6/ApiExtractor/reporthandler.cpp
@@ -33,6 +33,7 @@ static ReportHandler::DebugLevel m_debugLevel = ReportHandler::NoDebug;
 static QSet<QString> m_reportedWarnings;
 static QString m_prefix;
 static bool m_withinProgress = false;
+static QByteArray m_progressMessage;
 static int m_step_warning = 0;
 static QElapsedTimer m_timer;
 
@@ -147,9 +148,13 @@ void ReportHandler::startProgress(const QByteArray& str)
         endProgress();
 
     m_withinProgress = true;
-    const auto ts = '[' + timeStamp() + ']';
-    std::printf("%s %8s %-60s", qPrintable(m_prefix), ts.constData(), str.constData());
-    std::fflush(stdout);
+    m_progressMessage = str;
+}
+
+static void indentStdout(qsizetype n)
+{
+    for (qsizetype i = 0; i < n; ++i)
+        fputc(' ', stdout);
 }
 
 void ReportHandler::endProgress()
@@ -158,11 +163,23 @@ void ReportHandler::endProgress()
         return;
 
     m_withinProgress = false;
+
+    std::fputs(m_prefix.toUtf8().constData(), stdout);
+    const auto ts = timeStamp();
+    if (ts.size() < 6)
+        indentStdout(6 - ts.size());
+    std::fputs(" [", stdout);
+    std::fputs(ts.constData(), stdout);
+    std::fputs("] ", stdout);
+    std::fputs(m_progressMessage.constData(), stdout);
+    if (m_progressMessage.size() < 60)
+        indentStdout(60 - m_progressMessage.size());
     const char *endMessage = m_step_warning == 0
         ?  "[" COLOR_GREEN "OK" COLOR_END "]\n"
         : "[" COLOR_YELLOW "WARNING" COLOR_END "]\n";
     std::fputs(endMessage, stdout);
     std::fflush(stdout);
+    m_progressMessage.clear();
     m_step_warning = 0;
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/CMakeLists.txt b/sources/shiboken6/ApiExtractor/tests/CMakeLists.txt
index 97ae0f850..76c014fbb 100644
--- a/sources/shiboken6/ApiExtractor/tests/CMakeLists.txt
+++ b/sources/shiboken6/ApiExtractor/tests/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 set(CMAKE_AUTORCC ON)
 
 macro(declare_test testname)
@@ -15,7 +18,7 @@ macro(declare_test testname)
                                                    ${CMAKE_CURRENT_BINARY_DIR}
                                                    ${apiextractor_SOURCE_DIR}
                                                    )
-    target_link_libraries(${testname} PRIVATE apiextractor Qt${QT_MAJOR_VERSION}::Test)
+    target_link_libraries(${testname} PRIVATE apiextractor Qt::Test)
     add_test(${testname} ${testname})
     if (INSTALL_TESTS)
         install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${testname}
diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
index 8021810b3..4b5da0c3a 100644
--- a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
@@ -23,7 +23,7 @@ void TestAbstractMetaClass::testClassName()
     <value-type name="ClassName"/>
 </typesystem>)";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     QCOMPARE(classes[0]->name(), u"ClassName");
@@ -39,7 +39,7 @@ void TestAbstractMetaClass::testClassNameUnderNamespace()
         </namespace-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2); // 1 namespace + 1 class
     if (classes.constFirst()->name() != u"ClassName")
@@ -71,7 +71,7 @@ void TestAbstractMetaClass::testClassNameUnderNamespace()
     // QVERIFY(classes[0]->hasNonPrivateConstructor());
 }
 
-static AbstractMetaFunctionCList virtualFunctions(const AbstractMetaClass *c)
+static AbstractMetaFunctionCList virtualFunctions(const AbstractMetaClassCPtr &c)
 {
     AbstractMetaFunctionCList result;
     const auto &functions = c->functions();
@@ -110,13 +110,13 @@ public:
 </typesystem>
 )XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 4);
-    auto *a = AbstractMetaClass::findClass(classes, u"A");
-    auto *b = AbstractMetaClass::findClass(classes, u"B");
-    auto *c = AbstractMetaClass::findClass(classes, u"C");
-    const AbstractMetaClass *f = AbstractMetaClass::findClass(classes, u"F");
+    const auto a = AbstractMetaClass::findClass(classes, "A");
+    const auto b = AbstractMetaClass::findClass(classes, "B");
+    const auto c = AbstractMetaClass::findClass(classes, "C");
+    const auto f = AbstractMetaClass::findClass(classes, "F");
     QVERIFY(f);
 
     QCOMPARE(a->baseClass(), nullptr);
@@ -159,11 +159,11 @@ public:
     const auto funcF = virtualFunctionsF.constFirst();
 
     QCOMPARE(funcA->ownerClass(), a);
-    QVERIFY(funcC->attributes().testFlag(AbstractMetaFunction::VirtualCppMethod));
+    QVERIFY(funcC->isVirtual());
     QCOMPARE(funcB->ownerClass(), b);
     QCOMPARE(funcC->ownerClass(), c);
-    QVERIFY(funcC->attributes().testFlag(AbstractMetaFunction::OverriddenCppMethod));
-    QVERIFY(funcF->attributes().testFlag(AbstractMetaFunction::FinalCppMethod));
+    QVERIFY(funcC->cppAttributes().testFlag(FunctionAttribute::Override));
+    QVERIFY(funcF->cppAttributes().testFlag(FunctionAttribute::Final));
 
     QCOMPARE(funcA->declaringClass(), a);
     QCOMPARE(funcB->declaringClass(), a);
@@ -194,12 +194,12 @@ class Derived : public Base {};
 </typesystem>
 )XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    auto base = AbstractMetaClass::findClass(classes, u"Base");
+    const auto base = AbstractMetaClass::findClass(classes, "Base");
     QVERIFY(base);
     QVERIFY(base->isPolymorphic());
-    auto derived = AbstractMetaClass::findClass(classes, u"Derived");
+    const auto derived = AbstractMetaClass::findClass(classes, "Derived");
     QVERIFY(derived);
     QVERIFY(derived->isPolymorphic());
 }
@@ -218,10 +218,10 @@ void TestAbstractMetaClass::testDefaultValues()
         </value-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     const auto candidates = classA->queryFunctionsByName(u"method"_s);
     QCOMPARE(candidates.size(), 1);
     const auto &method = candidates.constFirst();
@@ -248,10 +248,10 @@ void TestAbstractMetaClass::testModifiedDefaultValues()
         </value-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     const auto methodMatches = classA->queryFunctionsByName(u"method"_s);
     QCOMPARE(methodMatches.size(), 1);
     const auto method = methodMatches.constFirst();
@@ -274,13 +274,13 @@ void TestAbstractMetaClass::testInnerClassOfAPolymorphicOne()
         </object-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QVERIFY(classA->isPolymorphic());
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"A::B");
+    const auto classB = AbstractMetaClass::findClass(classes, "A::B");
     QVERIFY(classB);
     QVERIFY(!classB->isPolymorphic());
 }
@@ -302,15 +302,15 @@ void TestAbstractMetaClass::testForwardDeclaredInnerClass()
         </value-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"A::B");
+    const auto classB = AbstractMetaClass::findClass(classes, "A::B");
     QVERIFY(classB);
-    const auto fooF = classB->findFunction(u"foo");
-    QVERIFY(!fooF.isNull());
+    const auto fooF = classB->findFunction("foo");
+    QVERIFY(fooF);
 }
 
 void TestAbstractMetaClass::testSpecialFunctions()
@@ -333,11 +333,11 @@ void TestAbstractMetaClass::testSpecialFunctions()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
 
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     auto ctors = classA->queryFunctions(FunctionQueryOption::AnyConstructor);
     QCOMPARE(ctors.size(), 2);
@@ -348,7 +348,7 @@ void TestAbstractMetaClass::testSpecialFunctions()
     QCOMPARE(assigmentOps.constFirst()->functionType(),
              AbstractMetaFunction::AssignmentOperatorFunction);
 
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     ctors = classB->queryFunctions(FunctionQueryOption::AnyConstructor);
     QCOMPARE(ctors.size(), 2);
@@ -399,11 +399,11 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 6);
 
-    auto *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 2);
 
@@ -417,28 +417,28 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     QCOMPARE(ctors[1]->arguments().size(), 1);
     QCOMPARE(ctors[1]->minimalSignature(), u"A(A)");
 
-    auto *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     QCOMPARE(classB->functions().size(), 2);
     QCOMPARE(classB->functions().constFirst()->minimalSignature(), u"B()");
 
-    auto *classC = AbstractMetaClass::findClass(classes, u"C");
+    const auto classC = AbstractMetaClass::findClass(classes, "C");
     QVERIFY(classC);
     QCOMPARE(classC->functions().size(), 1);
     QCOMPARE(classC->functions().constFirst()->minimalSignature(), u"C(C)");
 
-    auto *classD = AbstractMetaClass::findClass(classes, u"D");
+    const auto classD = AbstractMetaClass::findClass(classes, "D");
     QVERIFY(classD);
     QCOMPARE(classD->functions().size(), 1);
     QCOMPARE(classD->functions().constFirst()->minimalSignature(), u"D(D)");
     QVERIFY(classD->functions().constFirst()->isPrivate());
 
-    auto *classE = AbstractMetaClass::findClass(classes, u"E");
+    const auto classE = AbstractMetaClass::findClass(classes, "E");
     QVERIFY(classE);
     QVERIFY(classE->hasPrivateDestructor());
     QCOMPARE(classE->functions().size(), 0);
 
-    auto *classF = AbstractMetaClass::findClass(classes, u"F");
+    const auto classF = AbstractMetaClass::findClass(classes, "F");
     QVERIFY(classF);
 
     ctors = classF->queryFunctions(FunctionQueryOption::AnyConstructor);
@@ -468,10 +468,10 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     auto ctors = classA->queryFunctions(FunctionQueryOption::AnyConstructor);
@@ -485,7 +485,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
     QCOMPARE(ctors[1]->minimalSignature(), u"A(A)");
     QVERIFY(ctors[1]->isPrivate());
 
-    auto *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
 
     ctors = classB->queryFunctions(FunctionQueryOption::Constructors);
@@ -506,10 +506,10 @@ void TestAbstractMetaClass::testAbstractClassDefaultConstructors()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    auto *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     const auto ctors = classA->queryFunctions(FunctionQueryOption::Constructors);
@@ -527,10 +527,10 @@ void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    auto *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     const auto ctors = classA->queryFunctions(FunctionQueryOption::Constructors);
@@ -563,13 +563,13 @@ void TestAbstractMetaClass::testIsPolymorphic()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto *b = AbstractMetaClass::findClass(classes, u"A");
+    const auto b = AbstractMetaClass::findClass(classes, "A");
 
     QVERIFY(!b->isPolymorphic());
-    auto *a = AbstractMetaClass::findClass(classes, u"B");
+    const auto a = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(!a->isPolymorphic());
 }
 
@@ -593,12 +593,12 @@ class Derived : public BaseAlias2 {
 )XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto base = AbstractMetaClass::findClass(classes, u"Base");
+    const auto base = AbstractMetaClass::findClass(classes, "Base");
     QVERIFY(base);
-    auto derived = AbstractMetaClass::findClass(classes, u"Derived");
+    const auto derived = AbstractMetaClass::findClass(classes, "Derived");
     QVERIFY(derived);
     QCOMPARE(derived->baseClasses().value(0), base);
 }
@@ -644,7 +644,7 @@ void TestAbstractMetaClass::testFreeOperators()
     </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(code.constData(), xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     QVERIFY(classes.constFirst()->hasArithmeticOperatorOverload());
@@ -678,12 +678,12 @@ public:
 )XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto base = AbstractMetaClass::findClass(classes, u"Base");
+    const auto base = AbstractMetaClass::findClass(classes, "Base");
     QVERIFY(base);
-    auto derived = AbstractMetaClass::findClass(classes, u"Derived");
+    const auto derived = AbstractMetaClass::findClass(classes, "Derived");
     QVERIFY(derived);
     const auto usingMembers = derived->usingMembers();
     QCOMPARE(usingMembers.size(), 2);
@@ -733,9 +733,9 @@ void TestAbstractMetaClass::testUsingTemplateMembers()
 )XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(code.constData(), xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    auto valueList = AbstractMetaClass::findClass(classes, u"ValueList");
+    const auto valueList = AbstractMetaClass::findClass(classes, "ValueList");
     QVERIFY(valueList);
     auto list = valueList->templateBaseClass();
     QVERIFY(valueList->isUsingMember(list, u"append"_s, Access::Public));
@@ -763,9 +763,9 @@ public:
 )XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    auto *tc = AbstractMetaClass::findClass(classes, u"TestClass");
+    const auto tc = AbstractMetaClass::findClass(classes, "TestClass");
     // Verify that the constructor and 2 functions are generated.
     const auto &functions = tc->functions();
     QCOMPARE(functions.size(), 5);
diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
index 072764155..2c320c874 100644
--- a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
@@ -54,7 +54,7 @@ void TestAbstractMetaType::testConstCharPtrType()
         <function signature='justAtest()' />\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     QCOMPARE(builder->globalFunctions().size(), 1);
     const auto func = builder->globalFunctions().constFirst();
     AbstractMetaType rtype = func->type();
@@ -87,7 +87,7 @@ void TestAbstractMetaType::testApiVersionSupported()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 false, u"1.0"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
@@ -105,7 +105,7 @@ void TestAbstractMetaType::testApiVersionNotSupported()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 true, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
@@ -120,7 +120,7 @@ void TestAbstractMetaType::testCharType()
     <function signature='justAtest()'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
@@ -157,11 +157,11 @@ void TestAbstractMetaType::testTypedef()
     <value-type name='C' />\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const AbstractMetaClass *c = AbstractMetaClass::findClass(classes, u"C");
+    const auto c = AbstractMetaClass::findClass(classes, "C");
     QVERIFY(c);
     QVERIFY(c->isTypeDef());
 }
@@ -182,7 +182,7 @@ void TestAbstractMetaType::testTypedefWithTemplates()
     <function signature='func(A&lt;B&gt;)'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
@@ -193,7 +193,7 @@ void TestAbstractMetaType::testTypedefWithTemplates()
     QCOMPARE(args.size(), 1);
     const AbstractMetaArgument &arg = args.constFirst();
     AbstractMetaType metaType = arg.type();
-    QCOMPARE(metaType.cppSignature(), u"A<B >");
+    QCOMPARE(metaType.cppSignature(), u"A<B>");
 }
 
 
@@ -207,11 +207,11 @@ void TestAbstractMetaType::testObjectTypeUsedAsValue()
     <object-type name='A'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     const auto overloads = classA->queryFunctionsByName(u"method"_s);
     QCOMPARE(overloads.size(), 1);
diff --git a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
index 72cf34693..a891e1e28 100644
--- a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
@@ -19,28 +19,31 @@
 
 using namespace Qt::StringLiterals;
 
+static constexpr auto voidT = "void"_L1;
+
 void TestAddFunction::testParsingFuncNameAndConstness()
 {
     // generic test...
-    const char sig1[] = "func(type1, const type2, const type3* const)";
+    static constexpr auto sig1 = "func(type1, const type2, const type3* const)"_L1;
     QString errorMessage;
-    auto f1 = AddedFunction::createAddedFunction(QLatin1StringView(sig1), u"void"_s,
-                                                 &errorMessage);
-    QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
+    auto f1 = AddedFunction::createAddedFunction(sig1, voidT, &errorMessage);
+    QVERIFY2(f1, qPrintable(errorMessage));
     QCOMPARE(f1->name(), u"func");
     QCOMPARE(f1->arguments().size(), 3);
     TypeInfo retval = f1->returnType();
-    QCOMPARE(retval.qualifiedName(), QStringList{u"void"_s});
+    QCOMPARE(retval.qualifiedName(), QStringList{voidT});
     QCOMPARE(retval.indirections(), 0);
     QCOMPARE(retval.isConstant(), false);
     QCOMPARE(retval.referenceType(), NoReference);
 
     // test with a ugly template as argument and other ugly stuff
-    const char sig2[] = "    _fu__nc_       (  type1, const type2, const Abc<int& , C<char*> *   >  * *@my_name@, const type3* const    )   const ";
-    auto f2 = AddedFunction::createAddedFunction(QLatin1StringView(sig2),
+    static constexpr auto sig2 =
+        "    _fu__nc_       (  type1, const type2, const Abc<int& , C<char*> *   >"
+        "  * *@my_name@, const type3* const    )   const "_L1;
+    auto f2 = AddedFunction::createAddedFunction(sig2,
                                                  u"const Abc<int& , C<char*> *   >  * *"_s,
                                                  &errorMessage);
-    QVERIFY2(!f2.isNull(), qPrintable(errorMessage));
+    QVERIFY2(f2, qPrintable(errorMessage));
     QCOMPARE(f2->name(), u"_fu__nc_");
     const auto &args = f2->arguments();
     QCOMPARE(args.size(), 4);
@@ -66,18 +69,15 @@ void TestAddFunction::testParsingFuncNameAndConstness()
     QVERIFY(args.at(3).name.isEmpty());
 
     // function with no args.
-    const char sig3[] = "func()";
-    auto f3 = AddedFunction::createAddedFunction(QLatin1StringView(sig3), u"void"_s,
-                                                 &errorMessage);
-    QVERIFY2(!f3.isNull(), qPrintable(errorMessage));
+    auto f3 = AddedFunction::createAddedFunction("func()"_L1, voidT, &errorMessage);
+    QVERIFY2(f3, qPrintable(errorMessage));
     QCOMPARE(f3->name(), u"func");
     QCOMPARE(f3->arguments().size(), 0);
 
     // const call operator
-    const char sig4[] = "operator()(int)const";
-    auto f4 = AddedFunction::createAddedFunction(QLatin1StringView(sig4), u"int"_s,
-                                                 &errorMessage);
-    QVERIFY2(!f4.isNull(), qPrintable(errorMessage));
+    auto f4 = AddedFunction::createAddedFunction("operator()(int)const"_L1,
+                                                 "int"_L1, &errorMessage);
+    QVERIFY2(f4, qPrintable(errorMessage));
     QCOMPARE(f4->name(), u"operator()");
     QCOMPARE(f4->arguments().size(), 1);
     QVERIFY(f4->isConstant());
@@ -102,15 +102,15 @@ struct A {
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     auto *typeDb = TypeDatabase::instance();
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     // default ctor, default copy ctor, func a() and the added functions
     QCOMPARE(classA->functions().size(), 5);
 
-    auto addedFunc = classA->findFunction(u"b");
+    auto addedFunc = classA->findFunction("b");
     QVERIFY(addedFunc);
     QCOMPARE(addedFunc->access(), Access::Protected);
     QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction);
@@ -131,7 +131,7 @@ struct A {
     QCOMPARE(args.at(1).defaultValueExpression(), u"4.6");
     QCOMPARE(args.at(2).type().typeEntry(), typeDb->findType(u"B"_s));
 
-    auto addedCallOperator = classA->findFunction(u"operator()");
+    auto addedCallOperator = classA->findFunction("operator()");
     QVERIFY(addedCallOperator);
 }
 
@@ -146,9 +146,9 @@ void TestAddFunction::testAddFunctionConstructor()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 3); // default and added ctors
     const auto addedFunc = classA->functions().constLast();
@@ -169,9 +169,9 @@ void TestAddFunction::testAddFunctionTagDefaultValues()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     // default ctor, default copy ctor and the added function
     QCOMPARE(classA->functions().size(), 3);
@@ -195,9 +195,9 @@ void TestAddFunction::testAddFunctionCodeSnippets()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     const auto addedFunc = classA->functions().constLast();
     QVERIFY(addedFunc->hasInjectedCode());
@@ -205,11 +205,10 @@ void TestAddFunction::testAddFunctionCodeSnippets()
 
 void TestAddFunction::testAddFunctionWithoutParenteses()
 {
-    const char sig1[] = "func";
+    static constexpr auto sig1 = "func"_L1;
     QString errorMessage;
-    auto f1 = AddedFunction::createAddedFunction(QLatin1StringView(sig1), u"void"_s,
-                                                 &errorMessage);
-    QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
+    auto f1 = AddedFunction::createAddedFunction(sig1, voidT, &errorMessage);
+    QVERIFY2(f1, qPrintable(errorMessage));
     QCOMPARE(f1->name(), u"func");
     QCOMPARE(f1->arguments().size(), 0);
     QCOMPARE(f1->isConstant(), false);
@@ -225,12 +224,12 @@ void TestAddFunction::testAddFunctionWithoutParenteses()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"func");
-    QVERIFY(!addedFunc.isNull());
+    const auto addedFunc = classA->findFunction(sig1);
+    QVERIFY(addedFunc);
     QVERIFY(addedFunc->hasInjectedCode());
     const auto snips = addedFunc->injectedCodeSnips(TypeSystem::CodeSnipPositionAny,
                                                     TypeSystem::TargetLangCode);
@@ -239,11 +238,10 @@ void TestAddFunction::testAddFunctionWithoutParenteses()
 
 void TestAddFunction::testAddFunctionWithDefaultArgs()
 {
-    const char sig1[] = "func";
+    static constexpr auto sig1 = "func"_L1;
     QString errorMessage;
-    auto f1 = AddedFunction::createAddedFunction(QLatin1StringView(sig1), u"void"_s,
-                                                 &errorMessage);
-    QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
+    auto f1 = AddedFunction::createAddedFunction(sig1, voidT, &errorMessage);
+    QVERIFY2(f1, qPrintable(errorMessage));
     QCOMPARE(f1->name(), u"func");
     QCOMPARE(f1->arguments().size(), 0);
     QCOMPARE(f1->isConstant(), false);
@@ -262,12 +260,12 @@ void TestAddFunction::testAddFunctionWithDefaultArgs()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"func");
-    QVERIFY(!addedFunc.isNull());
+    const auto addedFunc = classA->findFunction(sig1);
+    QVERIFY(addedFunc);
     const AbstractMetaArgument &arg = addedFunc->arguments().at(1);
     QCOMPARE(arg.defaultValueExpression(), u"2");
 }
@@ -285,9 +283,9 @@ void TestAddFunction::testAddFunctionAtModuleLevel()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     auto *typeDb = TypeDatabase::instance();
@@ -306,11 +304,10 @@ void TestAddFunction::testAddFunctionAtModuleLevel()
 
 void TestAddFunction::testAddFunctionWithVarargs()
 {
-    const char sig1[] = "func(int,char,...)";
     QString errorMessage;
-    auto f1 = AddedFunction::createAddedFunction(QLatin1StringView(sig1), u"void"_s,
+    auto f1 = AddedFunction::createAddedFunction("func(int,char,...)"_L1, voidT,
                                                  &errorMessage);
-    QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
+    QVERIFY2(f1, qPrintable(errorMessage));
     QCOMPARE(f1->name(), u"func");
     QCOMPARE(f1->arguments().size(), 3);
     QVERIFY(!f1->isConstant());
@@ -326,12 +323,12 @@ void TestAddFunction::testAddFunctionWithVarargs()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"func");
-    QVERIFY(!addedFunc.isNull());
+    const auto addedFunc = classA->findFunction("func");
+    QVERIFY(addedFunc);
     const AbstractMetaArgument &arg = addedFunc->arguments().constLast();
     QVERIFY(arg.type().isVarargs());
     QVERIFY(arg.type().typeEntry()->isVarargs());
@@ -350,12 +347,12 @@ void TestAddFunction::testAddStaticFunction()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"func");
-    QVERIFY(!addedFunc.isNull());
+    const auto addedFunc = classA->findFunction("func");
+    QVERIFY(addedFunc);
     QVERIFY(addedFunc->isStatic());
 }
 
@@ -375,13 +372,13 @@ void TestAddFunction::testAddGlobalFunction()
         <value-type name='B'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.size(), 2);
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(builder->classes(), u"B");
+    const auto classB = AbstractMetaClass::findClass(builder->classes(), "B");
     QVERIFY(classB);
-    QVERIFY(!classB->findFunction(u"globalFunc"));
-    QVERIFY(!classB->findFunction(u"globalFunc2"));
+    QVERIFY(!classB->findFunction("globalFunc"));
+    QVERIFY(!classB->findFunction("globalFunc2"));
     QVERIFY(!globalFuncs[0]->injectedCodeSnips().isEmpty());
     QVERIFY(!globalFuncs[1]->injectedCodeSnips().isEmpty());
 }
@@ -401,7 +398,7 @@ void TestAddFunction::testAddFunctionWithApiVersion()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 true, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.size(), 1);
 }
@@ -424,11 +421,11 @@ void TestAddFunction::testModifyAddedFunction()
 </typesystem>
 )";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    auto *foo = AbstractMetaClass::findClass(classes, u"Foo");
-    const auto method = foo->findFunction(u"method");
-    QVERIFY(!method.isNull());
+    const auto foo = AbstractMetaClass::findClass(classes, "Foo");
+    const auto method = foo->findFunction("method");
+    QVERIFY(method);
     QCOMPARE(method->arguments().size(), 2);
     const AbstractMetaArgument &arg = method->arguments().at(1);
     QCOMPARE(arg.defaultValueExpression(), u"0");
@@ -451,17 +448,17 @@ void TestAddFunction::testAddFunctionOnTypedef()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    auto *foo = AbstractMetaClass::findClass(classes, u"FooInt");
+    const auto foo = AbstractMetaClass::findClass(classes, "FooInt");
     QVERIFY(foo);
     QVERIFY(foo->hasNonPrivateConstructor());
     const auto &lst = foo->queryFunctions(FunctionQueryOption::AnyConstructor);
     for (const auto &f : lst)
         QVERIFY(f->signature().startsWith(f->name()));
     QCOMPARE(lst.size(), 2);
-    const auto method = foo->findFunction(u"method");
-    QVERIFY(!method.isNull());
+    const auto method = foo->findFunction("method");
+    QVERIFY(method);
 }
 
 void TestAddFunction::testAddFunctionWithTemplateArg()
@@ -475,7 +472,7 @@ void TestAddFunction::testAddFunctionWithTemplateArg()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     QCOMPARE(builder->globalFunctions().size(), 1);
     const auto func = builder->globalFunctions().constFirst();
     const AbstractMetaArgument &arg = func->arguments().constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
index e7c3a0106..6e1820bed 100644
--- a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
@@ -34,7 +34,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
 
     const AbstractMetaArgument &arg = classA->functions().constLast()->arguments().constFirst();
@@ -43,10 +43,10 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger()
     QCOMPARE(arg.type().arrayElementType()->name(), u"double");
 }
 
-static QString functionMinimalSignature(const AbstractMetaClass *c, const QString &name)
+static QString functionMinimalSignature(const AbstractMetaClassCPtr &c, const QString &name)
 {
     const auto f = c->findFunction(name);
-    return f.isNull() ? QString() : f->minimalSignature();
+    return f ? f->minimalSignature() : QString();
 }
 
 void TestArrayArgument::testArraySignature()
@@ -72,7 +72,7 @@ void TestArrayArgument::testArraySignature()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QCOMPARE(functionMinimalSignature(classA, u"mi1"_s),
              u"mi1(int[5])");
     QCOMPARE(functionMinimalSignature(classA, u"mi1c"_s),
@@ -108,7 +108,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValue()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    AbstractMetaClassPtr classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
 
     auto someEnum = classA->findEnum(u"SomeEnum"_s);
@@ -138,8 +138,8 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValueFromGlobalEnu
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    QVERIFY(builder);
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
 
     AbstractMetaEnum someEnum = builder->globalEnums().constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp b/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
index bb8c6882b..4829e6c33 100644
--- a/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
@@ -59,14 +59,14 @@ void TestCodeInjections::testReadFile()
         </value-type>\n\
     </typesystem>\n"_s;
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.toLocal8Bit().constData()));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
     QString code = classA->typeEntry()->codeSnips().constFirst().code();
     QVERIFY(code.indexOf(expected) != -1);
     QVERIFY(classA->typeEntry()->isValue());
-    auto vte = qSharedPointerCast<const ValueTypeEntry>(classA->typeEntry());
+    auto vte = std::static_pointer_cast<const ValueTypeEntry>(classA->typeEntry());
     code = vte->targetConversionRule();
     QVERIFY(code.indexOf(expected) != -1);
 }
@@ -85,9 +85,9 @@ void TestCodeInjections::testInjectWithValidApiVersion()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 true, u"1.0"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    auto *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
 }
 
@@ -105,10 +105,10 @@ void TestCodeInjections::testInjectWithInvalidApiVersion()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 true, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QCOMPARE(classA->typeEntry()->codeSnips().size(), 0);
 }
 
@@ -125,7 +125,7 @@ void TestCodeInjections::testTextStream()
     str << "\n2nd table\n|" << AlignedField("bla", 3, QTextStream::AlignLeft)
         << '|' << AlignedField(QString{}, 0, QTextStream::AlignLeft) << "|\n";
 
-static const char expected[] = R"(void foo(int a, int b) {
+constexpr auto expected = R"(void foo(int a, int b) {
     if (a == b)
         return a;
 #if Q_OS_WIN
@@ -141,9 +141,9 @@ static const char expected[] = R"(void foo(int a, int b) {
 
 2nd table
 |bla||
-)";
+)"_L1;
 
-    QCOMPARE(str.toString(), QLatin1String(expected));
+    QCOMPARE(str.toString(), expected);
 }
 
 void TestCodeInjections::testTextStreamRst()
diff --git a/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp b/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
index 4f8dcd4b7..0bb72b3c1 100644
--- a/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
@@ -28,15 +28,15 @@ void TestContainer::testContainerType()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     //search for class A
-    auto *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     auto baseContainer = classA->typeEntry()->baseContainerType();
     QVERIFY(baseContainer);
-    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer.data())->containerKind(),
+    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer.get())->containerKind(),
              ContainerTypeEntry::ListContainer);
 }
 
@@ -61,11 +61,11 @@ void TestContainer::testListOfValueType()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->templateBaseClassInstantiations().size(), 1);
     const AbstractMetaType templateInstanceType =
diff --git a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
index f7d4b0673..8f2b277af 100644
--- a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
@@ -33,11 +33,11 @@ void TestConversionOperator::testConversionOperator()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
-    const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, u"C");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
+    const auto classC = AbstractMetaClass::findClass(classes, "C");
     QVERIFY(classA);
     QVERIFY(classB);
     QVERIFY(classC);
@@ -53,7 +53,7 @@ void TestConversionOperator::testConversionOperator()
             break;
         }
     }
-    QVERIFY(!convOp.isNull());
+    QVERIFY(convOp);
     QVERIFY(classA->externalConversionOperators().contains(convOp));
 }
 
@@ -71,9 +71,9 @@ void TestConversionOperator::testConversionOperatorOfDiscardedClass()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->externalConversionOperators().size(), 0);
 }
@@ -95,10 +95,10 @@ void TestConversionOperator::testRemovedConversionOperator()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classA);
     QVERIFY(classB);
     QCOMPARE(classA->functions().size(), 2);
@@ -121,10 +121,10 @@ void TestConversionOperator::testConversionOperatorReturningReference()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classA);
     QVERIFY(classB);
     QCOMPARE(classA->functions().size(), 2);
@@ -155,10 +155,10 @@ void TestConversionOperator::testConversionOperatorReturningConstReference()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classA);
     QVERIFY(classB);
     QCOMPARE(classA->functions().size(), 2);
diff --git a/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp b/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp
index 0f3edcfe5..b5efd92a6 100644
--- a/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp
@@ -21,10 +21,10 @@ void TestConversionRuleTag::testConversionRuleTagWithFile()
 {
     // FIXME PYSIDE7 remove
     // temp file used later
-    const char conversionData[] = "Hi! I'm a conversion rule.";
+    constexpr auto conversionData = "Hi! I'm a conversion rule."_L1;
     QTemporaryFile file;
-    file.open();
-    QCOMPARE(file.write(conversionData), qint64(sizeof(conversionData)-1));
+    QVERIFY(file.open());
+    QCOMPARE(file.write(conversionData.constData()), conversionData.size());
     file.close();
 
     const char cppCode[] = "struct A {};\n";
@@ -35,15 +35,15 @@ void TestConversionRuleTag::testConversionRuleTagWithFile()
         </value-type>\n\
     </typesystem>\n"_s;
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.toLocal8Bit().data()));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     const auto typeEntry = classA->typeEntry();
     QVERIFY(typeEntry->isValue());
-    auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry);
+    auto vte = std::static_pointer_cast<const ValueTypeEntry>(typeEntry);
     QVERIFY(vte->hasTargetConversionRule());
-    QCOMPARE(vte->targetConversionRule(), QLatin1String(conversionData));
+    QCOMPARE(vte->targetConversionRule(), conversionData);
 }
 
 void TestConversionRuleTag::testConversionRuleTagReplace()
@@ -85,10 +85,10 @@ void TestConversionRuleTag::testConversionRuleTagReplace()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     auto *typeDb = TypeDatabase::instance();
     auto typeA = typeDb->findPrimitiveType(u"A"_s);
-    QVERIFY(!typeA.isNull());
+    QVERIFY(typeA);
 
     QVERIFY(typeA->hasCustomConversion());
     auto conversion = typeA->customConversion();
@@ -115,7 +115,7 @@ void TestConversionRuleTag::testConversionRuleTagReplace()
     QCOMPARE(toNative.sourceTypeName(), u"B");
     QVERIFY(!toNative.isCustomType());
     auto typeB = typeDb->findType(u"B"_s);
-    QVERIFY(!typeB.isNull());
+    QVERIFY(typeB);
     QCOMPARE(toNative.sourceType(), typeB);
     QCOMPARE(toNative.sourceTypeCheck(), u"CheckIfInputObjectIsB(%IN)");
     QCOMPARE(toNative.conversion().trimmed(), u"%OUT = %IN.createA();");
@@ -153,12 +153,12 @@ if (!TargetDateTimeAPI) TargetDateTime_IMPORT;\n\
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
-    auto *classA = AbstractMetaClass::findClass(builder->classes(), u"Date");
+    QVERIFY(builder);
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "Date");
     QVERIFY(classA);
 
     QVERIFY(classA->typeEntry()->isValue());
-    auto vte = qSharedPointerCast<const ValueTypeEntry>(classA->typeEntry());
+    auto vte = std::static_pointer_cast<const ValueTypeEntry>(classA->typeEntry());
     QVERIFY(vte->hasCustomConversion());
     auto conversion = vte->customConversion();
 
@@ -216,10 +216,10 @@ void TestConversionRuleTag::testConversionRuleTagWithInsertTemplate()
     "// TEMPLATE - target_to_native - END";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     auto *typeDb = TypeDatabase::instance();
     auto typeA = typeDb->findPrimitiveType(u"A"_s);
-    QVERIFY(!typeA.isNull());
+    QVERIFY(typeA);
 
     QVERIFY(typeA->hasCustomConversion());
     auto conversion = typeA->customConversion();
diff --git a/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp b/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
index 7579509ff..c3a3ebef0 100644
--- a/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
@@ -19,16 +19,16 @@ void TestCtorInformation::testCtorIsPrivate()
                                 <value-type name='CtorLess'/>\n\
                            </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
-    auto *klass = AbstractMetaClass::findClass(classes, u"Control");
+    auto klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(klass->hasNonPrivateConstructor());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(!klass->hasNonPrivateConstructor());
-    klass = AbstractMetaClass::findClass(classes, u"CtorLess");
+    klass = AbstractMetaClass::findClass(classes, "CtorLess");
     QVERIFY(klass);
     QVERIFY(klass->hasNonPrivateConstructor());
 }
@@ -45,12 +45,12 @@ void TestCtorInformation::testHasNonPrivateCtor()
                                 <object-type name='Derived'/>\n\
                            </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const AbstractMetaClass *base = AbstractMetaClass::findClass(classes, u"Base");
+    const auto base = AbstractMetaClass::findClass(classes, "Base");
     QCOMPARE(base->hasNonPrivateConstructor(), true);
-    const AbstractMetaClass *derived = AbstractMetaClass::findClass(classes, u"Derived");
+    const auto derived = AbstractMetaClass::findClass(classes, "Derived");
     QCOMPARE(derived->hasNonPrivateConstructor(), true);
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
index 2e07b8cba..16f50e69d 100644
--- a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
@@ -56,16 +56,16 @@ void TestDropTypeEntries::testDropEntries()
         u"Foo.NamespaceA.InnerNamespaceA"_s};
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false,
                                                                 QString(), droppedEntries));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ValueA"));
-    QVERIFY(!AbstractMetaClass::findClass(classes, u"ValueB"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ObjectA"));
-    QVERIFY(!AbstractMetaClass::findClass(classes, u"ObjectB"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"NamespaceA"));
-    QVERIFY(!AbstractMetaClass::findClass(classes, u"NamespaceA::InnerClassA"));
-    QVERIFY(!AbstractMetaClass::findClass(classes, u"NamespaceB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ValueA"));
+    QVERIFY(!AbstractMetaClass::findClass(classes, "ValueB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ObjectA"));
+    QVERIFY(!AbstractMetaClass::findClass(classes, "ObjectB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "NamespaceA"));
+    QVERIFY(!AbstractMetaClass::findClass(classes, "NamespaceA::InnerClassA"));
+    QVERIFY(!AbstractMetaClass::findClass(classes, "NamespaceB"));
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.size(), 1);
@@ -79,16 +79,16 @@ void TestDropTypeEntries::testDropEntries()
 void TestDropTypeEntries::testDontDropEntries()
 {
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ValueA"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ValueB"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ObjectA"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ObjectB"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"NamespaceA"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"NamespaceA::InnerClassA"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"NamespaceB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ValueA"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ValueB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ObjectA"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ObjectB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "NamespaceA"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "NamespaceA::InnerClassA"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "NamespaceB"));
 
     QCOMPARE(builder->globalEnums().size(), 2);
 
@@ -115,21 +115,21 @@ void TestDropTypeEntries::testDropEntryWithChildTags()
     QStringList droppedEntries(u"Foo.ValueA"_s);
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode2, xmlCode2, false,
                                                                 QString(), droppedEntries));
-    QVERIFY(!builder.isNull());
-    QVERIFY(!AbstractMetaClass::findClass(builder->classes(), u"ValueA"));
+    QVERIFY(builder);
+    QVERIFY(!AbstractMetaClass::findClass(builder->classes(), "ValueA"));
 }
 
 
 void TestDropTypeEntries::testDontDropEntryWithChildTags()
 {
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode2, xmlCode2, false));
-    QVERIFY(!builder.isNull());
-    QVERIFY(AbstractMetaClass::findClass(builder->classes(), u"ValueA"));
+    QVERIFY(builder);
+    QVERIFY(AbstractMetaClass::findClass(builder->classes(), "ValueA"));
 }
 
 void TestDropTypeEntries::testConditionalParsing_data()
 {
-    const QString xml = QStringLiteral(R"(<?xml version="1.0" encoding="UTF-8"?>
+    const QString xml = R"(<?xml version="1.0" encoding="UTF-8"?>
 <root>
     <tag1>text</tag1>
     <?if keyword1?>
@@ -145,17 +145,17 @@ void TestDropTypeEntries::testConditionalParsing_data()
     <?if !keyword99?> <!-- Exclusion only -->
         <tag6>text</tag6>
     <?endif?>
-</root>)");
-
-    const QString root = QStringLiteral("root");
-    const QString tag1 = QStringLiteral("tag1");
-    const QString tag2 = QStringLiteral("tag2");
-    const QString tag3 = QStringLiteral("tag3");
-    const QString tag4 = QStringLiteral("tag4");
-    const QString tag5 = QStringLiteral("tag5");
-    const QString tag6 = QStringLiteral("tag6");
-    const QString keyword1 = QStringLiteral("keyword1");
-    const QString keyword2 = QStringLiteral("keyword2");
+</root>)"_L1;
+
+    constexpr auto root = "root"_L1;
+    constexpr auto tag1 = "tag1"_L1;
+    constexpr auto tag2 = "tag2"_L1;
+    constexpr auto tag3 = "tag3"_L1;
+    constexpr auto tag4 = "tag4"_L1;
+    constexpr auto tag5 = "tag5"_L1;
+    constexpr auto tag6 = "tag6"_L1;
+    constexpr auto keyword1 = "keyword1"_L1;
+    constexpr auto keyword2 = "keyword2"_L1;
 
     QTest::addColumn<QString>("xml");
     QTest::addColumn<QStringList>("keywords");
@@ -204,11 +204,11 @@ void TestDropTypeEntries::testConditionalParsing()
 
 void TestDropTypeEntries::testEntityParsing()
 {
-    const QString xml = QStringLiteral(R"(<?xml version="1.0" encoding="UTF-8"?>
+    const QString xml = R"(<?xml version="1.0" encoding="UTF-8"?>
 <root>
     <?entity testentity word1 word2?>
     <text>bla &testentity;</text>
-</root>)");
+</root>)"_L1;
 
     QString actual;
     ConditionalStreamReader reader(xml);
diff --git a/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp b/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
index 95b33243e..2152d39de 100644
--- a/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
@@ -25,13 +25,13 @@ private:
 </typesystem>)";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto *klass = AbstractMetaClass::findClass(classes, u"Control");
+    auto klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(!klass->hasPrivateDestructor());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(klass->hasPrivateDestructor());
 }
@@ -53,13 +53,13 @@ protected:
 </typesystem>)";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto *klass = AbstractMetaClass::findClass(classes, u"Control");
+    auto klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(!klass->hasProtectedDestructor());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(klass->hasProtectedDestructor());
 }
@@ -81,13 +81,13 @@ protected:
 </typesystem>)";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto *klass = AbstractMetaClass::findClass(classes, u"Control");
+    auto klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(!klass->hasVirtualDestructor());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(klass->hasVirtualDestructor());
 }
@@ -106,21 +106,21 @@ class Subject : public SubjectBase {};
 </typesystem>
 )XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 4);
 
-    auto klass = AbstractMetaClass::findClass(classes, u"ControlBase");
+    auto klass = AbstractMetaClass::findClass(classes, "ControlBase");
     QVERIFY(klass);
     QVERIFY(!klass->hasVirtualDestructor());
-    klass = AbstractMetaClass::findClass(classes, u"Control");
+    klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(!klass->hasVirtualDestructor());
 
-    klass = AbstractMetaClass::findClass(classes, u"SubjectBase");
+    klass = AbstractMetaClass::findClass(classes, "SubjectBase");
     QVERIFY(klass);
     QVERIFY(klass->hasVirtualDestructor());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(klass->hasVirtualDestructor());
 }
@@ -142,13 +142,13 @@ protected:
 </typesystem>)";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto *klass = AbstractMetaClass::findClass(classes, u"Control");
+    auto klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(klass->isPolymorphic());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(klass->isPolymorphic());
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testenum.cpp b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
index e45da9e70..c7c2b8b3b 100644
--- a/sources/shiboken6/ApiExtractor/tests/testenum.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
@@ -38,7 +38,7 @@ void TestEnum::testEnumCppSignature()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
 
@@ -54,7 +54,7 @@ void TestEnum::testEnumCppSignature()
              u"A::ClassEnum");
 
     // enum as parameter of a method
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QCOMPARE(classA->enums().size(), 1);
     const auto funcs = classA->queryFunctionsByName(u"method"_s);
     QVERIFY(!funcs.isEmpty());
@@ -93,7 +93,7 @@ void TestEnum::testEnumWithApiVersion()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 true, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     QCOMPARE(classes[0]->enums().size(), 1);
@@ -119,7 +119,7 @@ void TestEnum::testAnonymousEnum()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.size(), 1);
@@ -174,7 +174,7 @@ void TestEnum::testGlobalEnums()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.size(), 2);
@@ -222,7 +222,7 @@ void TestEnum::testEnumValueFromNeighbourEnum()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
@@ -284,9 +284,9 @@ void TestEnum::testEnumValueFromExpression()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
-    AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    AbstractMetaClassPtr classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
 
     auto enumA = classA->findEnum(u"EnumA"_s);
@@ -362,9 +362,9 @@ void TestEnum::testPrivateEnum()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
-    AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
     QCOMPARE(classA->enums().size(), 2);
 
@@ -401,7 +401,7 @@ void TestEnum::testTypedefEnum()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.size(), 1);
@@ -426,7 +426,7 @@ void TestEnum::testTypedefEnum()
 
 struct EnumDefaultValuesFixture
 {
-    QSharedPointer<AbstractMetaBuilder> builder;
+    std::shared_ptr<AbstractMetaBuilder> builder;
 
     AbstractMetaType globalEnum;
     AbstractMetaType testEnum;
@@ -462,7 +462,7 @@ namespace Test2
 )";
 
     fixture->builder.reset(TestUtil::parse(cppCode, xmlCode, false));
-    if (fixture->builder.isNull())
+    if (!fixture->builder)
         return -1;
 
     const auto globalEnums = fixture->builder->globalEnums();
@@ -472,8 +472,8 @@ namespace Test2
     fixture->globalEnum = AbstractMetaType(globalEnums.constFirst().typeEntry());
     fixture->globalEnum.decideUsagePattern();
 
-    const AbstractMetaClass *testNamespace = nullptr;
-    for (auto *c : fixture->builder->classes()) {
+    AbstractMetaClassCPtr testNamespace;
+    for (const auto &c : fixture->builder->classes()) {
         if (c->name() == u"Test2") {
             testNamespace = c;
             break;
@@ -486,8 +486,8 @@ namespace Test2
     if (namespaceEnums.size() != 2)
         return -4;
     QList<EnumTypeEntryCPtr > enumTypeEntries{
-        qSharedPointerCast<const EnumTypeEntry>(namespaceEnums.at(0).typeEntry()),
-        qSharedPointerCast<const EnumTypeEntry>(namespaceEnums.at(1).typeEntry())};
+        std::static_pointer_cast<const EnumTypeEntry>(namespaceEnums.at(0).typeEntry()),
+        std::static_pointer_cast<const EnumTypeEntry>(namespaceEnums.at(1).typeEntry())};
     if (enumTypeEntries.constFirst()->flags())
         std::swap(enumTypeEntries[0], enumTypeEntries[1]);
     fixture->testEnum = AbstractMetaType(enumTypeEntries.at(0));
diff --git a/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp b/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
index 048626d2a..fcc409a42 100644
--- a/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
@@ -21,9 +21,9 @@ void TestExtraInclude::testClassExtraInclude()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     QList<Include> includes = classA->typeEntry()->extraIncludes();
@@ -44,13 +44,13 @@ void TestExtraInclude::testGlobalExtraIncludes()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    QVERIFY(AbstractMetaClass::findClass(classes, u"A"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "A"));
 
     auto *td = TypeDatabase::instance();
     TypeSystemTypeEntryCPtr module = td->defaultTypeSystemType();
-    QVERIFY(!module.isNull());
+    QVERIFY(module);
     QCOMPARE(module->name(), u"Foo");
 
     QList<Include> includes = module->extraIncludes();
diff --git a/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp b/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp
index 4a98047f1..18eaf5774 100644
--- a/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp
@@ -23,7 +23,7 @@ void TestFunctionTag::testFunctionTagForSpecificSignature()
         <function signature='globalFunction(int)'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     TypeEntryCPtr func = TypeDatabase::instance()->findType(u"globalFunction"_s);
     QVERIFY(func);
@@ -41,10 +41,10 @@ void TestFunctionTag::testFunctionTagForAllSignatures()
         <function signature='globalFunction(float)'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     TypeEntryCPtr func = TypeDatabase::instance()->findType(u"globalFunction"_s);
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
     QCOMPARE(builder->globalFunctions().size(), 2);
 }
 
@@ -56,10 +56,10 @@ void TestFunctionTag::testRenameGlobalFunction()
         <function signature='global_function_with_ugly_name()' rename='smooth'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     TypeEntryCPtr func = TypeDatabase::instance()->findType(u"global_function_with_ugly_name"_s);
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
 
     QCOMPARE(builder->globalFunctions().size(), 1);
     const auto metaFunc = builder->globalFunctions().constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
index eabd8b046..899d00ad4 100644
--- a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
@@ -29,12 +29,12 @@ void TestImplicitConversions::testWithPrivateCtors()
         <value-type name='C'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
-    const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, u"C");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classC = AbstractMetaClass::findClass(classes, "C");
     const auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.size(), 1);
     QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(),
@@ -59,11 +59,11 @@ void TestImplicitConversions::testWithModifiedVisibility()
 </typesystem>
 )";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     const auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.size(), 1);
     QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(),
@@ -93,16 +93,16 @@ void TestImplicitConversions::testWithAddedCtor()
         <value-type name='C'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.size(), 2);
 
     // Added constructors with custom types should never result in implicit converters.
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     implicitConvs = classB->implicitConversions();
     QCOMPARE(implicitConvs.size(), 0);
 }
@@ -120,11 +120,11 @@ void TestImplicitConversions::testWithExternalConversionOperator()
         <value-type name='B'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto *classA = AbstractMetaClass::findClass(classes, u"A");
-    auto *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     const auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.size(), 1);
     const auto &externalConvOps = classA->externalConversionOperators();
@@ -135,7 +135,7 @@ void TestImplicitConversions::testWithExternalConversionOperator()
         if (func->isConversionOperator())
             convOp = func;
     }
-    QVERIFY(!convOp.isNull());
+    QVERIFY(convOp);
     QCOMPARE(implicitConvs.constFirst(), convOp);
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp b/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
index ffab76923..23cf0f9ea 100644
--- a/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
@@ -25,10 +25,10 @@ void TestInsertTemplate::testInsertTemplateOnClassInjectCode()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
     QString code = classA->typeEntry()->codeSnips().constFirst().code();
@@ -48,12 +48,12 @@ void TestInsertTemplate::testInsertTemplateOnModuleInjectCode()
         </inject-code>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QVERIFY(classes.isEmpty());
 
     TypeSystemTypeEntryCPtr module = TypeDatabase::instance()->defaultTypeSystemType();
-    QVERIFY(!module.isNull());
+    QVERIFY(module);
     QCOMPARE(module->name(), u"Foo");
     QCOMPARE(module->codeSnips().size(), 1);
     QString code = module->codeSnips().constFirst().code().trimmed();
diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
index 168f1a67b..9cf2e0cc7 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
@@ -33,8 +33,8 @@ R"(<typesystem package="Foo">
 </typesystem>
 )";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
-    AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    QVERIFY(builder);
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
     DocModificationList docMods = classA->typeEntry()->docModifications();
     QCOMPARE(docMods.size(), 2);
@@ -47,7 +47,7 @@ R"(<typesystem package="Foo">
     // cannot handle Qt resources.
     QTemporaryDir tempDir(QDir::tempPath() + u"/shiboken_testmodifydocXXXXXX"_s);
     QVERIFY2(tempDir.isValid(), qPrintable(tempDir.errorString()));
-    const QString docFileName = u"a.xml"_s;
+    constexpr auto docFileName = "a.xml"_L1;
     QVERIFY(QFile::copy(u":/"_s + docFileName, tempDir.filePath(docFileName)));
 
     QtDocParser docParser;
@@ -94,11 +94,11 @@ void TestModifyDocumentation::testInjectAddedFunctionDocumentation()
 </typesystem>
 )XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
-    AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    QVERIFY(builder);
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
-    const auto f = classA->findFunction(u"foo");
-    QVERIFY(!f.isNull());
+    const auto f = classA->findFunction("foo");
+    QVERIFY(f);
     QVERIFY(f->isUserAdded());
     auto docMods = f->addedFunctionDocModifications();
     QCOMPARE(docMods.size(), 1);
diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
index 2b2525a8c..a7d40f70a 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
@@ -46,11 +46,11 @@ void TestModifyFunction::testRenameArgument()
 
     const QByteArray xmlCode = QByteArray(xmlCode1) + pattern + QByteArray(xmlCode2);
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.constData(), false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
-    const auto func = classA->findFunction(u"method");
-    QVERIFY(!func.isNull());
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto func = classA->findFunction("method");
+    QVERIFY(func);
 
     QCOMPARE(func->argumentName(1), u"otherArg");
 }
@@ -74,11 +74,11 @@ void TestModifyFunction::testOwnershipTransfer()
         </object-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
-    const auto func = classB->findFunction(u"method");
-    QVERIFY(!func.isNull());
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
+    const auto func = classB->findFunction("method");
+    QVERIFY(func);
 
     QCOMPARE(func->argumentTargetOwnership(func->ownerClass(), 0),
              TypeSystem::CppOwnership);
@@ -124,47 +124,47 @@ void TestModifyFunction::invalidateAfterUse()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 false, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
-    auto func = classB->findFunction(u"call");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
+    auto func = classB->findFunction("call");
     QCOMPARE(func->modifications().size(), 1);
     QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
     QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
 
-    const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, u"C");
+    const auto classC = AbstractMetaClass::findClass(classes, "C");
     QVERIFY(classC);
-    func = classC->findFunction(u"call");
+    func = classC->findFunction("call");
     QCOMPARE(func->modifications().size(), 1);
     QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
     QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
 
-    func = classC->findFunction(u"call2");
+    func = classC->findFunction("call2");
     QCOMPARE(func->modifications().size(), 1);
     QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
     QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
 
-    const AbstractMetaClass *classD =  AbstractMetaClass::findClass(classes, u"D");
+    AbstractMetaClassCPtr classD =  AbstractMetaClass::findClass(classes, "D");
     QVERIFY(classD);
-    func = classD->findFunction(u"call");
+    func = classD->findFunction("call");
     QCOMPARE(func->modifications().size(), 1);
     QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
     QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
 
-    func = classD->findFunction(u"call2");
+    func = classD->findFunction("call2");
     QCOMPARE(func->modifications().size(), 1);
     QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
     QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
 
-    const AbstractMetaClass *classE = AbstractMetaClass::findClass(classes, u"E");
+    const auto classE = AbstractMetaClass::findClass(classes, "E");
     QVERIFY(classE);
-    func = classE->findFunction(u"call");
+    func = classE->findFunction("call");
     QVERIFY(func);
     QCOMPARE(func->modifications().size(), 1);
     QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
     QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
 
-    func = classE->findFunction(u"call2");
+    func = classE->findFunction("call2");
     QVERIFY(func);
     QCOMPARE(func->modifications().size(), 1);
     QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
@@ -197,15 +197,15 @@ void TestModifyFunction::testWithApiVersion()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 false, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    auto *classB = AbstractMetaClass::findClass(classes, u"B");
-    auto func = classB->findFunction(u"method");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
+    auto func = classB->findFunction("method");
 
     auto returnOwnership = func->argumentTargetOwnership(func->ownerClass(), 0);
     QCOMPARE(returnOwnership, TypeSystem::CppOwnership);
 
-    func = classB->findFunction(u"methodB");
+    func = classB->findFunction("methodB");
     returnOwnership = func->argumentTargetOwnership(func->ownerClass(), 0);
     QVERIFY(returnOwnership != TypeSystem::CppOwnership);
 }
@@ -236,34 +236,34 @@ struct A {
 )XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 false, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     // Nothing specified, true
-    const auto f1 = classA->findFunction(u"f1");
-    QVERIFY(!f1.isNull());
+    const auto f1 = classA->findFunction("f1");
+    QVERIFY(f1);
     QVERIFY(!f1->allowThread());
 
     // 'auto' specified, should be false for nontrivial function
-    const auto f2 = classA->findFunction(u"f2");
-    QVERIFY(!f2.isNull());
+    const auto f2 = classA->findFunction("f2");
+    QVERIFY(f2);
     QVERIFY(f2->allowThread());
 
     // 'no' specified, should be false
-    const auto f3 = classA->findFunction(u"f3");
-    QVERIFY(!f3.isNull());
+    const auto f3 = classA->findFunction("f3");
+    QVERIFY(f3);
     QVERIFY(!f3->allowThread());
 
     // Nothing specified, should be false for simple getter
-    const auto getter1 = classA->findFunction(u"getter1");
-    QVERIFY(!getter1.isNull());
+    const auto getter1 = classA->findFunction("getter1");
+    QVERIFY(getter1);
     QVERIFY(!getter1->allowThread());
 
     // Forced to true simple getter
-    const auto getter2 = classA->findFunction(u"getter2");
-    QVERIFY(!getter2.isNull());
+    const auto getter2 = classA->findFunction("getter2");
+    QVERIFY(getter2);
     QVERIFY(getter2->allowThread()); // Forced to true simple getter
 }
 
@@ -286,7 +286,7 @@ void TestModifyFunction::testGlobalFunctionModification()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     QCOMPARE(builder->globalFunctions().size(), 1);
 
     auto *td = TypeDatabase::instance();
@@ -434,44 +434,44 @@ void TestModifyFunction::testScopedModifications()
     QFETCH(bool, expectedAllowThread);
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode.constData(), xmlCode.constData(), false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
 
-    auto f = classA->findFunction(QStringLiteral("unspecified"));
-    QVERIFY(!f.isNull());
+    auto f = classA->findFunction("unspecified");
+    QVERIFY(f);
     QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::Unknown);
     QCOMPARE(f->generateExceptionHandling(), expectedGenerateUnspecified);
     QCOMPARE(f->allowThread(), expectedAllowThread);
 
-    f = classA->findFunction(QStringLiteral("nonThrowing"));
-    QVERIFY(!f.isNull());
+    f = classA->findFunction("nonThrowing");
+    QVERIFY(f);
     QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::NoExcept);
     QCOMPARE(f->generateExceptionHandling(), expectedGenerateNonThrowing);
 
-    f = classA->findFunction(QStringLiteral("throwing"));
-    QVERIFY(!f.isNull());
+    f = classA->findFunction("throwing");
+    QVERIFY(f);
     QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::Throws);
     QCOMPARE(f->generateExceptionHandling(), expectedGenerateThrowing);
 }
 
 void TestModifyFunction::testSnakeCaseRenaming_data()
 {
-    QTest::addColumn<QString>("name");
-    QTest::addColumn<QString>("expected");
+    QTest::addColumn<QLatin1StringView>("name");
+    QTest::addColumn<QLatin1StringView>("expected");
     QTest::newRow("s1")
-        << QStringLiteral("snakeCaseFunc") << QStringLiteral("snake_case_func");
+        << "snakeCaseFunc"_L1 << "snake_case_func"_L1;
     QTest::newRow("s2")
-        << QStringLiteral("SnakeCaseFunc") << QStringLiteral("snake_case_func");
+        << "SnakeCaseFunc"_L1 << "snake_case_func"_L1;
     QTest::newRow("consecutive-uppercase")
-        << QStringLiteral("snakeCAseFunc") << QStringLiteral("snakeCAseFunc");
+        << "snakeCAseFunc"_L1 << "snakeCAseFunc"_L1;
 }
 
 void TestModifyFunction::testSnakeCaseRenaming()
 {
-    QFETCH(QString, name);
-    QFETCH(QString, expected);
+    QFETCH(QLatin1StringView, name);
+    QFETCH(QLatin1StringView, expected);
 
     const QString actual = AbstractMetaBuilder::getSnakeCaseName(name);
     QCOMPARE(actual, expected);
diff --git a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
index a3f955602..1cf4c8e0f 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
@@ -31,11 +31,11 @@ void TestMultipleInheritance::testVirtualClass()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 4);
 
-    const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, u"D");
+    const auto classD = AbstractMetaClass::findClass(classes, "D");
     bool functionFound = false;
     for (const auto &f : classD->functions()) {
         if (f->name() == u"theBug") {
diff --git a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
index 248812048..3773e614a 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
@@ -31,14 +31,14 @@ void NamespaceTest::testNamespaceMembers()
         </namespace-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass *ns = AbstractMetaClass::findClass(classes, u"Namespace");
+    const auto ns = AbstractMetaClass::findClass(classes, "Namespace");
     QVERIFY(ns);
     auto metaEnum = ns->findEnum(u"Option"_s);
     QVERIFY(metaEnum.has_value());
-    const auto func = ns->findFunction(u"foo");
-    QVERIFY(!func.isNull());
+    const auto func = ns->findFunction("foo");
+    QVERIFY(func);
 }
 
 void NamespaceTest::testNamespaceInnerClassMembers()
@@ -61,16 +61,16 @@ void NamespaceTest::testNamespaceInnerClassMembers()
         </namespace-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *ons = AbstractMetaClass::findClass(classes, u"OuterNamespace");
+    const auto ons = AbstractMetaClass::findClass(classes, "OuterNamespace");
     QVERIFY(ons);
-    const AbstractMetaClass *ins = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace");
+    const auto ins = AbstractMetaClass::findClass(classes, "OuterNamespace::InnerNamespace");
     QVERIFY(ins);
-    const AbstractMetaClass *sc = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace::SomeClass");
+    const auto sc = AbstractMetaClass::findClass(classes, "OuterNamespace::InnerNamespace::SomeClass");
     QVERIFY(sc);
-    const auto meth = sc->findFunction(u"method");
-    QVERIFY(!meth.isNull());
+    const auto meth = sc->findFunction("method");
+    QVERIFY(meth);
 }
 
 QTEST_APPLESS_MAIN(NamespaceTest)
diff --git a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
index f6daab0b8..10ca1a0f6 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
@@ -43,13 +43,13 @@ void TestNestedTypes::testNestedTypesModifications()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    auto *ons = AbstractMetaClass::findClass(classes, u"OuterNamespace");
+    const auto ons = AbstractMetaClass::findClass(classes, "OuterNamespace");
     QVERIFY(ons);
 
-    auto *ins = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace");
+    const auto ins = AbstractMetaClass::findClass(classes, "OuterNamespace::InnerNamespace");
     QVERIFY(ins);
     QCOMPARE(ins->functions().size(), 1);
     QCOMPARE(ins->typeEntry()->codeSnips().size(), 1);
@@ -68,8 +68,9 @@ void TestNestedTypes::testNestedTypesModifications()
     snip = addedFunc->modifications().constFirst().snips().constFirst();
     QCOMPARE(snip.code().trimmed(), u"custom_code2();");
 
-    auto *sc = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace::SomeClass");
-    QVERIFY(ins);
+    const auto sc =
+        AbstractMetaClass::findClass(classes, "OuterNamespace::InnerNamespace::SomeClass");
+    QVERIFY(sc);
     QCOMPARE(sc->functions().size(), 2); // default constructor and removed method
     const auto removedFunc = sc->functions().constLast();
     QVERIFY(removedFunc->isModifiedRemoved());
@@ -92,23 +93,23 @@ void TestNestedTypes::testDuplicationOfNestedTypes()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto *nspace = AbstractMetaClass::findClass(classes, u"Namespace");
+    const auto nspace = AbstractMetaClass::findClass(classes, "Namespace");
     QVERIFY(nspace);
-    auto *cls1 = AbstractMetaClass::findClass(classes, u"SomeClass");
+    const auto cls1 = AbstractMetaClass::findClass(classes, "SomeClass");
     QVERIFY(cls1);
-    auto *cls2 = AbstractMetaClass::findClass(classes, u"Namespace::SomeClass");
+    const auto cls2 = AbstractMetaClass::findClass(classes, "Namespace::SomeClass");
     QVERIFY(cls2);
     QCOMPARE(cls1, cls2);
     QCOMPARE(cls1->name(), u"SomeClass");
     QCOMPARE(cls1->qualifiedCppName(), u"Namespace::SomeClass");
 
     auto t1 = TypeDatabase::instance()->findType(u"Namespace::SomeClass"_s);
-    QVERIFY(!t1.isNull());
+    QVERIFY(t1);
     auto t2 = TypeDatabase::instance()->findType(u"SomeClass"_s);
-    QVERIFY(t2.isNull());
+    QVERIFY(!t2);
 }
 
 QTEST_APPLESS_MAIN(TestNestedTypes)
diff --git a/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp b/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp
index 8dc9b641b..9eef7ec47 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp
@@ -24,7 +24,7 @@ void TestNumericalTypedef::testNumericalTypedef()
         <function signature='funcReal(real)'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     QCOMPARE(builder->globalFunctions().size(), 2);
     auto funcDouble = builder->globalFunctions().constFirst();
@@ -63,7 +63,7 @@ void TestNumericalTypedef::testUnsignedNumericalTypedef()
         <function signature='funcUShort(custom_ushort)'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     QCOMPARE(builder->globalFunctions().size(), 2);
     auto funcUnsignedShort = builder->globalFunctions().constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp b/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
index ba2b25829..99cced09d 100644
--- a/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
@@ -23,15 +23,15 @@ void TestPrimitiveTypeTag::testPrimitiveTypeDefaultConstructor()
         <object-type name='B'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
 
     auto typeEntry = TypeDatabase::instance()->findPrimitiveType(u"A"_s);
-    QVERIFY(!typeEntry.isNull());
+    QVERIFY(typeEntry);
     QVERIFY(typeEntry->hasDefaultConstructor());
     QCOMPARE(typeEntry->defaultConstructor(), u"A()");
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
index ef83d99fb..f2e261624 100644
--- a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
@@ -32,11 +32,11 @@ void TestRefCountTag::testReferenceCountTag()
         </object-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
-    const auto func = classB->findFunction(u"keepObject");
-    QVERIFY(!func.isNull());
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
+    const auto func = classB->findFunction("keepObject");
+    QVERIFY(func);
     const auto refCount =
         func->modifications().constFirst().argument_mods().constFirst().referenceCounts().constFirst();
     QCOMPARE(refCount.action, ReferenceCount::Add);
@@ -66,11 +66,11 @@ void TestRefCountTag::testWithApiVersion()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 false, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
-    const auto func = classB->findFunction(u"keepObject");
-    QVERIFY(!func.isNull());
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
+    const auto func = classB->findFunction("keepObject");
+    QVERIFY(func);
     const auto refCount =
         func->modifications().constFirst().argument_mods().constFirst().referenceCounts().constFirst();
     QCOMPARE(refCount.action, ReferenceCount::Add);
diff --git a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
index 74a0adcea..ae85c5a86 100644
--- a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
@@ -23,12 +23,12 @@ void TestReferenceToPointer::testReferenceToPointerArgument()
         <object-type name='B'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
-    const auto func = classB->findFunction(u"dummy");
-    QVERIFY(!func.isNull());
+    const auto func = classB->findFunction("dummy");
+    QVERIFY(func);
     QCOMPARE(func->arguments().constFirst().type().minimalSignature(), u"A*&");
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp b/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp
index e0acb0e5b..2cc82071b 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp
@@ -4,10 +4,15 @@
 #include "testremovefield.h"
 #include <QtTest/QTest>
 #include "testutil.h"
+#include <abstractmetaargument.h>
 #include <abstractmetafield.h>
+#include <abstractmetafunction.h>
+#include <abstractmetatype.h>
 #include <abstractmetalang.h>
 #include <typesystem.h>
 
+using namespace Qt::StringLiterals;
+
 void TestRemoveField::testRemoveField()
 {
     const char cppCode[] = "\
@@ -23,15 +28,49 @@ void TestRemoveField::testRemoveField()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->fields().size(), 1);
     const AbstractMetaField &fieldA = classA->fields().constFirst();
     QCOMPARE(fieldA.name(), u"fieldA");
 }
 
+// Verify that 'static constexpr' fields are seen as static/const and
+// appear fully qualified for function parameter default values.
+void TestRemoveField::testConstExprField()
+{
+    const char cppCode[] = R"(
+struct A {
+    static constexpr int constExprField = 44;
+
+    void f(int iParam=constExprField);
+};
+)";
+
+    const char xmlCode[] = R"(
+<typesystem package="Foo">
+    <value-type name='A'/>
+</typesystem>
+)";
+
+    QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
+    QVERIFY(builder);
+    AbstractMetaClassList classes = builder->classes();
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    QVERIFY(classA);
+    const auto &fields = classA->fields();
+    QCOMPARE(fields.size(), 1);
+    QVERIFY(fields.constFirst().isStatic());
+    QVERIFY(fields.constFirst().type().isConstant());
+    const auto function = classA->findFunction("f"_L1);
+    QVERIFY(function);
+    const auto &arguments = function->arguments();
+    QCOMPARE(arguments.size(), 1);
+    QCOMPARE(arguments.constFirst().defaultValueExpression(), "A::constExprField"_L1);
+}
+
 QTEST_APPLESS_MAIN(TestRemoveField)
 
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testremovefield.h b/sources/shiboken6/ApiExtractor/tests/testremovefield.h
index febe672ce..05912d99e 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremovefield.h
+++ b/sources/shiboken6/ApiExtractor/tests/testremovefield.h
@@ -11,6 +11,7 @@ class TestRemoveField : public QObject
     Q_OBJECT
     private slots:
         void testRemoveField();
+        void testConstExprField();
 };
 
 #endif
diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
index 59528d517..87e318e95 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
@@ -30,14 +30,14 @@ void TestRemoveImplConv::testRemoveImplConv()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
-    const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, u"C");
+    const auto classC = AbstractMetaClass::findClass(classes, "C");
     QVERIFY(classC);
     const auto implConv = classC->implicitConversions();
     QCOMPARE(implConv.size(), 1);
diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
index a6d929c8f..17a069b5e 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
@@ -15,28 +15,29 @@ using namespace Qt::StringLiterals;
 
 void TestRemoveOperatorMethod::testRemoveOperatorMethod()
 {
-    const char cppCode[] = "\
-    #include <stdint.h>\n\
-    \n\
-    struct Char {};\n\
-    struct ByteArray {};\n\
-    struct String {};\n\
-    \n\
-    struct A {\n\
-        A& operator>>(char&);\n\
-        A& operator>>(char*);\n\
-        A& operator>>(short&);\n\
-        A& operator>>(unsigned short&);\n\
-        A& operator>>(int&);\n\
-        A& operator>>(unsigned int&);\n\
-        A& operator>>(int64_t&);\n\
-        A& operator>>(uint64_t&);\n\
-        A& operator>>(float&);\n\
-        A& operator>>(double&);\n\
-        A& operator>>(Char&);\n\
-        A& operator>>(ByteArray&);\n\
-        A& operator>>(String&);\n\
-    };\n";
+    const char cppCode[] = R"(#include <cstdint>
+
+struct Char {};
+struct ByteArray {};
+struct String {};
+
+struct A {
+    A& operator>>(char&);
+    A& operator>>(char*);
+    A& operator>>(short&);
+    A& operator>>(unsigned short&);
+    A& operator>>(int&);
+    A& operator>>(unsigned int&);
+    A& operator>>(int64_t&);
+    A& operator>>(uint64_t&);
+    A& operator>>(float&);
+    A& operator>>(double&);
+    A& operator>>(Char&);
+    A& operator>>(ByteArray&);
+    A& operator>>(String&);
+};
+)";
+
     const char xmlCode[] = "\
     <typesystem package='Foo'>\n\
         <primitive-type name='char'/>\n\
@@ -67,9 +68,9 @@ void TestRemoveOperatorMethod::testRemoveOperatorMethod()
         </object-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 14);
     QStringList removedSignatures;
diff --git a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
index a798c4339..67ebcc606 100644
--- a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
@@ -4,10 +4,12 @@
 #include "testresolvetype.h"
 #include "testutil.h"
 #include <abstractmetaargument.h>
+#include <abstractmetaenum.h>
 #include <abstractmetafunction.h>
 #include <abstractmetalang.h>
 #include <abstractmetatype.h>
 #include <complextypeentry.h>
+#include <enumtypeentry.h>
 #include <primitivetypeentry.h>
 #include <typedatabase.h>
 
@@ -45,12 +47,12 @@ void TestResolveType::testResolveReturnTypeFromParentScope()
         </namespace-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, u"A::D");
+    const auto classD = AbstractMetaClass::findClass(classes, "A::D");
     QVERIFY(classD);
-    const auto meth = classD->findFunction(u"method");
-    QVERIFY(!meth.isNull());
+    const auto meth = classD->findFunction("method");
+    QVERIFY(meth);
     QVERIFY(meth);
 }
 
@@ -60,13 +62,14 @@ void TestResolveType::testResolveReturnTypeFromParentScope()
 
 struct DefaultValuesFixture
 {
-    QSharedPointer<AbstractMetaBuilder> builder;
+    std::shared_ptr<AbstractMetaBuilder> builder;
 
     AbstractMetaType intType;
     AbstractMetaType stringType;
     AbstractMetaType classType;
     AbstractMetaType listType;
-    const AbstractMetaClass *klass{};
+    AbstractMetaType enumType;
+    AbstractMetaClassCPtr klass{};
 };
 
 Q_DECLARE_METATYPE(DefaultValuesFixture)
@@ -91,6 +94,7 @@ public:
 
     static const int INT_FIELD_1 = 42;
     static const char *CHAR_FIELD_1;
+    static const Enum DefaultValue = enumValue1;
 };
 } // Namespace
 )";
@@ -106,7 +110,7 @@ public:
 )";
 
     fixture->builder.reset(TestUtil::parse(cppCode, xmlCode, false));
-    if (fixture->builder.isNull())
+    if (!fixture->builder)
         return -1;
 
     for (const auto &klass : fixture->builder->classes()) {
@@ -121,7 +125,7 @@ public:
     fixture->classType = AbstractMetaType(fixture->klass->typeEntry());
     fixture->classType.decideUsagePattern();
 
-    for (const auto &f : fixture->klass->findFunctions(u"Test"_s)) {
+    for (const auto &f : fixture->klass->findFunctions("Test")) {
         if (f->functionType() == AbstractMetaFunction::ConstructorFunction
             && f->arguments().size() == 1) {
             const auto type = f->arguments().constFirst().type();
@@ -134,11 +138,14 @@ public:
     if (fixture->intType.isVoid() || fixture->stringType.isVoid())
         return -3;
 
-    auto listFunc = fixture->klass->findFunction(u"listFunc"_s);
-    if (listFunc.isNull() || listFunc->arguments().size() != 1)
+    auto listFunc = fixture->klass->findFunction("listFunc");
+    if (!listFunc || listFunc->arguments().size() != 1)
         return -3;
     fixture->listType = listFunc->arguments().constFirst().type();
 
+    fixture->enumType = AbstractMetaType(fixture->klass->enums().constFirst().typeEntry());
+    fixture->enumType.decideUsagePattern();
+
     return 0;
 }
 
@@ -213,6 +220,11 @@ void TestResolveType::testFixDefaultArguments_data()
     QTest::newRow("self from enum")
         << fixture << setupOk << fixture.classType
         << "Test(enumValue1)" << expected;
+
+    // Don't qualify fields to "Test::Enum::DefaultValue"
+    QTest::newRow("enum from static field")
+        << fixture << setupOk << fixture.enumType
+        << "DefaultValue" << u"Namespace::Test::DefaultValue"_s;
 }
 
 void TestResolveType::testFixDefaultArguments()
@@ -251,16 +263,16 @@ public:
 )";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *testClass = AbstractMetaClass::findClass(classes, u"Test");
+    const auto testClass = AbstractMetaClass::findClass(classes, "Test");
     QVERIFY(testClass);
 
     auto *tdb = TypeDatabase::instance();
     auto int32TEntry = tdb->findType(u"int32_t"_s);
-    QVERIFY2(!int32TEntry.isNull(), "int32_t not found");
+    QVERIFY2(int32TEntry, "int32_t not found");
     QVERIFY(int32TEntry->isPrimitive());
-    auto int32T = qSharedPointerCast<const PrimitiveTypeEntry>(int32TEntry);
+    auto int32T = std::static_pointer_cast<const PrimitiveTypeEntry>(int32TEntry);
     auto basicType = basicReferencedTypeEntry(int32T);
     QVERIFY2(basicType != int32T,
              "Typedef for int32_t not found. Check the system include paths.");
diff --git a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
index 0e191668b..f4eecff2c 100644
--- a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
@@ -25,9 +25,9 @@ void TestReverseOperators::testReverseSum()
     </typesystem>";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    auto *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 4);
 
@@ -42,10 +42,10 @@ void TestReverseOperators::testReverseSum()
         }
     }
 
-    QVERIFY(!normalOp.isNull());
+    QVERIFY(normalOp);
     QVERIFY(!normalOp->isReverseOperator());
     QCOMPARE(normalOp->arguments().size(), 1);
-    QVERIFY(!reverseOp.isNull());
+    QVERIFY(reverseOp);
     QVERIFY(reverseOp->isReverseOperator());
     QCOMPARE(reverseOp->arguments().size(), 1);
 }
@@ -67,13 +67,13 @@ void TestReverseOperators::testReverseSumWithAmbiguity()
     </typesystem>";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 4);
 
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     QCOMPARE(classB->functions().size(), 4);
 
@@ -87,11 +87,11 @@ void TestReverseOperators::testReverseSumWithAmbiguity()
                 normalOp = func;
         }
     }
-    QVERIFY(!normalOp.isNull());
+    QVERIFY(normalOp);
     QVERIFY(!normalOp->isReverseOperator());
     QCOMPARE(normalOp->arguments().size(), 1);
     QCOMPARE(normalOp->minimalSignature(), u"operator+(B,A)");
-    QVERIFY(!reverseOp.isNull());
+    QVERIFY(reverseOp);
     QVERIFY(reverseOp->isReverseOperator());
     QCOMPARE(reverseOp->arguments().size(), 1);
     QCOMPARE(reverseOp->minimalSignature(), u"operator+(A,B)");
@@ -111,10 +111,10 @@ void  TestReverseOperators::testSpaceshipOperator()
         </typesystem>)";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false,
                                                                 {}, {}, LanguageLevel::Cpp20));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const AbstractMetaClass *testClass = AbstractMetaClass::findClass(classes, u"Test");
+    const auto testClass = AbstractMetaClass::findClass(classes, "Test");
     QVERIFY(testClass);
     const auto &functions = testClass->functions();
     // 6 operators should be synthesized
diff --git a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
index 65c95e378..ea37c6255 100644
--- a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
@@ -55,16 +55,16 @@ namespace Internet {
 </typesystem>)XML").arg(file.fileName());
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, qPrintable(xmlCode1), false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    auto *classB = AbstractMetaClass::findClass(classes, u"Bookmarks");
+    const auto classB = AbstractMetaClass::findClass(classes, "Bookmarks");
     QVERIFY(classB);
-    const auto func = classB->findFunction(u"list");
-    QVERIFY(!func.isNull());
+    const auto func = classB->findFunction("list");
+    QVERIFY(func);
     AbstractMetaType funcType = func->type();
     QVERIFY(!funcType.isVoid());
-    QCOMPARE(funcType.cppSignature(), u"QList<Internet::Url >");
+    QCOMPARE(funcType.cppSignature(), u"QList<Internet::Url>");
 }
 
 void TestTemplates::testTemplateOnContainers()
@@ -93,15 +93,15 @@ namespace Namespace {
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    auto *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
-    const auto func = classB->findFunction(u"foo");
-    QVERIFY(!func.isNull());
+    const auto func = classB->findFunction("foo");
+    QVERIFY(func);
     AbstractMetaType argType = func->arguments().constFirst().type();
     QCOMPARE(argType.instantiations().size(), 1);
     QCOMPARE(argType.typeEntry()->qualifiedCppName(), u"QList");
@@ -130,14 +130,14 @@ void func(List<int> arg) {}
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.size(), 1);
 
     const auto func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), u"func(List<int>)");
     QCOMPARE(func->arguments().constFirst().type().cppSignature(),
-             u"List<int >");
+             u"List<int>");
 }
 
 void TestTemplates::testTemplatePointerAsArgument()
@@ -155,14 +155,14 @@ void func(List<int>* arg) {}
  </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaFunctionCList globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.size(), 1);
 
     const auto func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), u"func(List<int>*)");
     QCOMPARE(func->arguments().constFirst().type().cppSignature(),
-             u"List<int > *");
+             u"List<int> *");
 }
 
 void TestTemplates::testTemplateReferenceAsArgument()
@@ -180,14 +180,14 @@ void func(List<int>& arg) {}
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.size(), 1);
 
     const auto func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), u"func(List<int>&)");
     QCOMPARE(func->arguments().constFirst().type().cppSignature(),
-             u"List<int > &");
+             u"List<int> &");
 }
 
 void TestTemplates::testTemplateParameterFixup()
@@ -209,21 +209,20 @@ struct List {
  </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const AbstractMetaClassList templates = builder->templates();
 
     QCOMPARE(templates.size(), 1);
-    const AbstractMetaClass *list = templates.constFirst();
-    // Verify that the parameter of "void append(List l)" gets fixed to "List<T >"
-    const auto append = list->findFunction(QStringLiteral("append"));
-    QVERIFY(!append.isNull());
+    AbstractMetaClassCPtr list = templates.constFirst();
+    // Verify that the parameter of "void append(List l)" gets fixed to "List<T>"
+    const auto append = list->findFunction("append");
+    QVERIFY(append);
     QCOMPARE(append->arguments().size(), 1);
-    QCOMPARE(append->arguments().at(0).type().cppSignature(), u"List<T >");
+    QCOMPARE(append->arguments().at(0).type().cppSignature(), u"List<T>");
     // Verify that the parameter of "void erase(Iterator)" is not modified
-    const auto erase = list->findFunction(QStringLiteral("erase"));
-    QVERIFY(!erase.isNull());
+    const auto erase = list->findFunction("erase");
+    QVERIFY(erase);
     QCOMPARE(erase->arguments().size(), 1);
-    QEXPECT_FAIL("", "Clang: Some other code changes the parameter type", Abort);
     QCOMPARE(erase->arguments().at(0).type().cppSignature(), u"List::Iterator");
 }
 
@@ -250,16 +249,16 @@ struct FooBars : public ListContainer<FooBar> {};
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     AbstractMetaClassList templates = builder->templates();
     QCOMPARE(classes.size(), 2);
     QCOMPARE(templates.size(), 1);
 
-    const auto *foobars = AbstractMetaClass::findClass(classes, u"FooBars");
+    const auto foobars = AbstractMetaClass::findClass(classes, "FooBars");
     QCOMPARE(foobars->functions().size(), 4);
 
-    const AbstractMetaClass *lc = templates.constFirst();
+    AbstractMetaClassCPtr lc = templates.constFirst();
     QCOMPARE(lc->functions().size(), 2);
 }
 
@@ -287,10 +286,10 @@ template<SomeEnum type> struct Future {};
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    auto *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
@@ -326,10 +325,10 @@ template<SomeEnum type> struct Future {};
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    auto *classB = AbstractMetaClass::findClass(classes, u"Namespace::B");
+    const auto classB = AbstractMetaClass::findClass(classes, "Namespace::B");
     QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
@@ -362,13 +361,13 @@ typedef BaseTemplateClass<TypeOne> TypeOneClass;
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
-    const auto *base = AbstractMetaClass::findClass(classes, u"BaseTemplateClass");
+    const auto base = AbstractMetaClass::findClass(classes, "BaseTemplateClass");
     QVERIFY(base);
-    const auto *one = AbstractMetaClass::findClass(classes, u"TypeOneClass");
+    const auto one = AbstractMetaClass::findClass(classes, "TypeOneClass");
     QVERIFY(one);
     QCOMPARE(one->templateBaseClass(), base);
     QCOMPARE(one->functions().size(), base->functions().size());
@@ -376,7 +375,7 @@ typedef BaseTemplateClass<TypeOne> TypeOneClass;
     auto oneType = one->typeEntry();
     auto baseType = base->typeEntry();
     QCOMPARE(oneType->baseContainerType(), baseType);
-    QCOMPARE(one->baseClassNames(), QStringList(u"BaseTemplateClass<TypeOne>"_s));
+    QCOMPARE(one->baseClassNames(), QStringList(u"NSpace::BaseTemplateClass<NSpace::TypeOne>"_s));
 
     QVERIFY(one->hasTemplateBaseClassInstantiations());
     AbstractMetaTypeList instantiations = one->templateBaseClassInstantiations();
@@ -411,27 +410,27 @@ typedef Vector<int> IntVector;
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
 
-    auto *vector = AbstractMetaClass::findClass(classes, u"IntVector");
+    const auto vector = AbstractMetaClass::findClass(classes, "IntVector");
     QVERIFY(vector);
     auto baseContainer = vector->typeEntry()->baseContainerType();
-    QVERIFY(!baseContainer.isNull());
-    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer.data())->containerKind(),
+    QVERIFY(baseContainer);
+    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer.get())->containerKind(),
              ContainerTypeEntry::ListContainer);
     QCOMPARE(vector->functions().size(), 4);
 
-    const auto method = vector->findFunction(u"method");
-    QVERIFY(!method.isNull());
-    QCOMPARE(method->signature(), u"method(const Vector<int > & vector)");
+    const auto method = vector->findFunction("method");
+    QVERIFY(method);
+    QCOMPARE(method->signature(), u"method(const Vector<int> & vector)");
 
-    const auto otherMethod = vector->findFunction(u"otherMethod");
-    QVERIFY(!otherMethod.isNull());
+    const auto otherMethod = vector->findFunction("otherMethod");
+    QVERIFY(otherMethod);
     QCOMPARE(otherMethod->signature(), u"otherMethod()");
     QVERIFY(!otherMethod->type().isVoid());
-    QCOMPARE(otherMethod->type().cppSignature(), u"Vector<int >");
+    QCOMPARE(otherMethod->type().cppSignature(), u"Vector<int>");
 }
 
 void TestTemplates::testNonTypeTemplates()
@@ -455,7 +454,7 @@ Array<int, 2> foo();
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     auto functions = builder->globalFunctions();
     QCOMPARE(functions.size(), 1);
     auto foo = functions.constFirst();
@@ -538,32 +537,30 @@ void TestTemplates::testTemplateTypeDefs()
     const QByteArray cppBa = cpp.toLocal8Bit();
     const QByteArray xmlBa = xml.toLocal8Bit();
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppBa.constData(), xmlBa.constData(), true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    const AbstractMetaClass *optional = AbstractMetaClass::findClass(classes, u"Optional");
+    const auto optional = AbstractMetaClass::findClass(classes, "Optional");
     QVERIFY(optional);
 
     // Find the typedef'ed class
-    const AbstractMetaClass *optionalInt =
-        AbstractMetaClass::findClass(classes, u"IntOptional");
+    const auto optionalInt = AbstractMetaClass::findClass(classes, "IntOptional");
     QVERIFY(optionalInt);
     QCOMPARE(optionalInt->templateBaseClass(), optional);
 
     // Find the class typedef'ed in the typesystem XML
-    const AbstractMetaClass *xmlOptionalInt =
-        AbstractMetaClass::findClass(classes, u"XmlIntOptional");
+    const auto xmlOptionalInt = AbstractMetaClass::findClass(classes, "XmlIntOptional");
     QVERIFY(xmlOptionalInt);
     QCOMPARE(xmlOptionalInt->templateBaseClass(), optional);
 
     // Check whether the value() method now has an 'int' return
-    const auto valueMethod = optionalInt->findFunction(u"value");
-    QVERIFY(!valueMethod.isNull());
+    const auto valueMethod = optionalInt->findFunction("value");
+    QVERIFY(valueMethod);
     QCOMPARE(valueMethod->type().cppSignature(), u"int");
 
     // ditto for typesystem XML
-    const auto xmlValueMethod = xmlOptionalInt->findFunction(u"value");
-    QVERIFY(!xmlValueMethod.isNull());
+    const auto xmlValueMethod = xmlOptionalInt->findFunction("value");
+    QVERIFY(xmlValueMethod);
     QCOMPARE(xmlValueMethod->type().cppSignature(), u"int");
 
     // Check whether the m_value field is of type 'int'
@@ -609,10 +606,10 @@ public:
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
-    auto testClass = AbstractMetaClass::findClass(classes, u"Test");
+    const auto testClass = AbstractMetaClass::findClass(classes, "Test");
     QVERIFY(testClass);
 
     auto fields = testClass->fields();
@@ -621,9 +618,10 @@ public:
     QCOMPARE(fieldType.name(), u"Container1");
     QCOMPARE(fieldType.instantiations().size(), 1);
 
-    auto derived = AbstractMetaClass::findClass(classes, u"Derived");
+    const auto derived = AbstractMetaClass::findClass(classes, "Derived");
     QVERIFY(derived);
     auto base = derived->templateBaseClass();
+    QVERIFY(base);
     QCOMPARE(base->name(), u"Container1");
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
index 1ebe71ef6..72dae8cc5 100644
--- a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
@@ -30,15 +30,15 @@ void TestTypeRevision::testRevisionAttr()
                         "</object-type>"
                         "</typesystem>";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *rev0 = AbstractMetaClass::findClass(classes, u"Rev_0");
+    const auto rev0 = AbstractMetaClass::findClass(classes, "Rev_0");
     QCOMPARE(rev0->typeEntry()->revision(), 0);
 
-    const AbstractMetaClass *rev1 = AbstractMetaClass::findClass(classes, u"Rev_1");
+    const auto rev1 = AbstractMetaClass::findClass(classes, "Rev_1");
     QCOMPARE(rev1->typeEntry()->revision(), 1);
 
-    AbstractMetaClass *rev2 = AbstractMetaClass::findClass(classes, u"Rev_2");
+    const auto rev2 = AbstractMetaClass::findClass(classes, "Rev_2");
     QCOMPARE(rev2->typeEntry()->revision(), 2);
 
     auto rev3 = rev2->findEnum(u"Rev_3"_s);
@@ -82,7 +82,7 @@ class Bar20 {};
 )XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true, version));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     QCOMPARE(builder->classes().size(), expectedClassCount);
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testutil.h b/sources/shiboken6/ApiExtractor/tests/testutil.h
index e19517e85..dc4e3b2da 100644
--- a/sources/shiboken6/ApiExtractor/tests/testutil.h
+++ b/sources/shiboken6/ApiExtractor/tests/testutil.h
@@ -27,19 +27,19 @@ namespace TestUtil
         auto *td = TypeDatabase::instance(true);
         if (apiVersion.isEmpty())
             TypeDatabase::clearApiVersions();
-        else if (!TypeDatabase::setApiVersion(QStringLiteral("*"), apiVersion))
+        else if (!TypeDatabase::setApiVersion(QLatin1StringView("*"), apiVersion))
             return nullptr;
         td->setDropTypeEntries(dropTypeEntries);
         QBuffer buffer;
         // parse typesystem
         buffer.setData(xmlCode);
         if (!buffer.open(QIODevice::ReadOnly))
-            return Q_NULLPTR;
+            return nullptr;
         if (!td->parseFile(&buffer))
             return nullptr;
         buffer.close();
         // parse C++ code
-        QTemporaryFile tempSource(QDir::tempPath() + QStringLiteral("/st_XXXXXX_main.cpp"));
+        QTemporaryFile tempSource(QDir::tempPath() + QLatin1StringView("/st_XXXXXX_main.cpp"));
         if (!tempSource.open()) {
             qWarning().noquote().nospace() << "Creation of temporary file failed: "
                 << tempSource.errorString();
diff --git a/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp b/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
index 06fbe9ee3..98e30eac2 100644
--- a/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
@@ -22,16 +22,16 @@ void TestValueTypeDefaultCtorTag::testValueTypeDefaultCtorTagArgument()
         <value-type name='B' />\n\
     </typesystem>";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
 
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QVERIFY(classA->typeEntry()->hasDefaultConstructor());
     QCOMPARE(classA->typeEntry()->defaultConstructor(), u"A(0, 0)");
 
-    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     QVERIFY(!classB->typeEntry()->hasDefaultConstructor());
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
index 255a33953..a600181a5 100644
--- a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
@@ -17,12 +17,12 @@ void TestVoidArg::testVoidParsedFunction()
         <value-type name='A'/>\n\
     </typesystem>";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"a");
-    QVERIFY(!addedFunc.isNull());
+    const auto addedFunc = classA->findFunction("a");
+    QVERIFY(addedFunc);
     QCOMPARE(addedFunc->arguments().size(), 0);
 }
 
@@ -36,12 +36,12 @@ void TestVoidArg::testVoidAddedFunction()
         </value-type>\n\
     </typesystem>";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"a");
-    QVERIFY(!addedFunc.isNull());
+    const auto addedFunc = classA->findFunction("a");
+    QVERIFY(addedFunc);
     QCOMPARE(addedFunc->arguments().size(), 0);
 
 }
@@ -54,12 +54,12 @@ void TestVoidArg::testVoidPointerParsedFunction()
         <value-type name='A' />\n\
     </typesystem>";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"a");
-    QVERIFY(!addedFunc.isNull());
+    const auto addedFunc = classA->findFunction("a");
+    QVERIFY(addedFunc);
     QCOMPARE(addedFunc->arguments().size(), 1);
 
 }
diff --git a/sources/shiboken6/ApiExtractor/textstream.h b/sources/shiboken6/ApiExtractor/textstream.h
index 074e23858..228f36405 100644
--- a/sources/shiboken6/ApiExtractor/textstream.h
+++ b/sources/shiboken6/ApiExtractor/textstream.h
@@ -31,7 +31,7 @@ public:
     virtual ~TextStream();
 
     Language language() const { return m_language; }
-    void setLanguage(const Language &language) { m_language = language; }
+    void setLanguage(Language language) { m_language = language; }
 
     bool isIndentationEnabled() const { return m_indentationEnabled; }
     void setIndentationEnabled(bool m)
@@ -77,6 +77,10 @@ public:
     void putRawChar(char c) { m_str << c; }
 
     TextStream &operator<<(QStringView v) { putString(v); return *this; }
+    TextStream &operator<<(const QString &qs) { putString(QStringView{qs}); return *this; }
+    TextStream &operator<<(QLatin1StringView lv) { putString(lv.constData()); return *this; }
+    TextStream &operator<<(QUtf8StringView uv) { putString(uv.data()); return *this; }
+    TextStream &operator<<(const QByteArray &ba) { putString(ba.constData()); return *this; }
     TextStream &operator<<(QChar c) { putChar(c); return *this; }
     TextStream &operator<<(const char *s) { putString(s); return *this; }
     TextStream &operator<<(char c) { putChar(c); return *this; }
@@ -85,7 +89,7 @@ public:
     TextStream &operator<<(qsizetype t) { putSizeType(t); return *this; }
 #endif
 
-    inline TextStream &operator<<(QTextStreamManipulator m) { m_str << m; return *this; }
+    inline TextStream &operator<<(const QTextStreamManipulator &m) { m_str << m; return *this; }
     inline TextStream &operator<<(ManipulatorFunc f) { f(*this); return *this; }
 
     void putRepetitiveChars(char c, int count);
@@ -140,6 +144,12 @@ void rstCodeOff(TextStream &s);
 void rstItalic(TextStream &s);
 void rstItalicOff(TextStream &s);
 
+inline TextStream &operator<<(TextStream &str, QAnyStringView asv)
+{
+    asv.visit([&str](auto s) { str << s; });
+    return str;
+}
+
 /// Format an aligned field
 template <class T>
 class AlignedField
@@ -179,6 +189,28 @@ TextStream &operator<<(TextStream &str, const AlignedField<T> &fa)
     return str;
 }
 
+class Pad
+{
+public:
+    explicit Pad(char c, int count) : m_char(c), m_count(count) {}
+
+    void write(TextStream &str) const
+    {
+        for (int i = 0; i < m_count; ++i)
+            str << m_char;
+    }
+
+private:
+    const char m_char;
+    const int m_count;
+};
+
+inline TextStream &operator<<(TextStream &str, const Pad &pad)
+{
+    pad.write(str);
+    return str;
+}
+
 class Indentation
 {
 public:
diff --git a/sources/shiboken6/ApiExtractor/typedatabase.cpp b/sources/shiboken6/ApiExtractor/typedatabase.cpp
index c185907b0..61fd22418 100644
--- a/sources/shiboken6/ApiExtractor/typedatabase.cpp
+++ b/sources/shiboken6/ApiExtractor/typedatabase.cpp
@@ -10,11 +10,14 @@
 #include "constantvaluetypeentry.h"
 #include "containertypeentry.h"
 #include "customtypenentry.h"
+#include "debughelpers_p.h"
+#include "exception.h"
 #include "flagstypeentry.h"
 #include "functiontypeentry.h"
 #include "namespacetypeentry.h"
 #include "objecttypeentry.h"
 #include "primitivetypeentry.h"
+#include "optionsparser.h"
 #include "pythontypeentry.h"
 #include "smartpointertypeentry.h"
 #include "typedefentry.h"
@@ -32,29 +35,29 @@
 #include <QtCore/QFile>
 #include <QtCore/QDebug>
 #include <QtCore/QDir>
-#include <QtCore/QPair>
 #include <QtCore/QList>
 #include <QtCore/QRegularExpression>
 #include <QtCore/QVersionNumber>
 #include <QtCore/QXmlStreamReader>
 #include "reporthandler.h"
-// #include <tr1/tuple>
+
 #include <algorithm>
+#include <utility>
 
 using namespace Qt::StringLiterals;
 
-using TypeDatabaseParserContextPtr = QSharedPointer<TypeDatabaseParserContext>;
+using TypeDatabaseParserContextPtr = std::shared_ptr<TypeDatabaseParserContext>;
 
 // package -> api-version
 
 static QString wildcardToRegExp(QString w)
 {
     w.replace(u'?', u'.');
-    w.replace(u'*', QStringLiteral(".*"));
+    w.replace(u'*', ".*"_L1);
     return w;
 }
 
-using ApiVersion =QPair<QRegularExpression, QVersionNumber>;
+using ApiVersion = std::pair<QRegularExpression, QVersionNumber>;
 using ApiVersions = QList<ApiVersion>;
 
 Q_GLOBAL_STATIC(ApiVersions, apiVersions)
@@ -85,7 +88,8 @@ static const PythonTypes &builtinPythonTypes()
         {u"PyObject"_s, u"true"_s, TypeSystem::CPythonType::Other},
         // shiboken-specific
         {u"PyPathLike"_s, u"Shiboken::String::checkPath"_s, TypeSystem::CPythonType::Other},
-        {u"PySequence"_s, u"Shiboken::String::checkIterable"_s, TypeSystem::CPythonType::Other},
+        {u"PySequence"_s, u"Shiboken::String::checkIterableArgument"_s,
+         TypeSystem::CPythonType::Other},
         {u"PyUnicode"_s, u"PyUnicode_Check"_s, TypeSystem::CPythonType::String},
         {u"PyTypeObject"_s, u"PyType_Check"_s, TypeSystem::CPythonType::Other},
         {u"str"_s, u"Shiboken::String::check"_s, TypeSystem::CPythonType::String},
@@ -100,7 +104,127 @@ static const PythonTypes &builtinPythonTypes()
     return result;
 }
 
-struct TypeDatabasePrivate
+struct SuppressedWarning
+{
+    QRegularExpression pattern;
+    QString rawText;
+    bool generate; // Current type system
+    mutable bool matched = false;
+};
+
+QList<OptionDescription> TypeDatabase::options()
+{
+    return {
+        {u"api-version=<\"package mask\">,<\"version\">"_s,
+         u"Specify the supported api version used to generate the bindings"_s},
+        {u"drop-type-entries=\"<TypeEntry0>[;TypeEntry1;...]\""_s,
+         u"Semicolon separated list of type system entries (classes, namespaces,\n"
+         "global functions and enums) to be dropped from generation."_s},
+        {u"-T<path>"_s, {} },
+        {u"typesystem-paths="_s + OptionsParser::pathSyntax(),
+         u"Paths used when searching for typesystems"_s},
+        {u"force-process-system-include-paths="_s + OptionsParser::pathSyntax(),
+         u"Include paths that are considered as system headers by the C++ parser, but should still "
+         "be processed to extract types (e.g. Qt include paths in a yocto sysroot)"_s},
+        {u"keywords=keyword1[,keyword2,...]"_s,
+         u"A comma-separated list of keywords for conditional typesystem parsing"_s},
+    };
+}
+
+struct TypeDatabaseOptions
+{
+    QStringList m_dropTypeEntries;
+    QStringList m_forceProcessSystemIncludes;
+    QStringList m_typesystemKeywords;
+    QStringList m_typesystemPaths;
+    bool m_suppressWarnings = true;
+};
+
+class TypeDatabaseOptionsParser : public OptionsParser
+{
+public:
+    explicit TypeDatabaseOptionsParser(TypeDatabaseOptions *o) : m_options(o) {}
+
+    bool handleBoolOption(const QString &key, OptionSource source) override;
+    bool handleOption(const QString &key, const QString &value, OptionSource source) override;
+
+private:
+    TypeDatabaseOptions *m_options;
+};
+
+bool TypeDatabaseOptionsParser::handleBoolOption(const QString &key, OptionSource source)
+{
+    switch (source) {
+    case OptionSource::CommandLine:
+    case OptionSource::ProjectFile:
+        if (key == u"no-suppress-warnings") {
+            m_options->m_suppressWarnings = false;
+            return true;
+        }
+        break;
+    case OptionSource::CommandLineSingleDash:
+        if (key.startsWith(u'T')) { // "-T/path" ends up a bool option
+            m_options->m_typesystemPaths += key.sliced(1).split(QDir::listSeparator(),
+                                                                Qt::SkipEmptyParts);
+            return true;
+        }
+        break;
+    }
+    return false;
+}
+
+bool TypeDatabaseOptionsParser::handleOption(const QString &key, const QString &value,
+                                             OptionSource source)
+{
+    if (source == OptionSource::CommandLineSingleDash)
+        return false;
+    if (key == u"api-version") {
+        const auto fullVersions = QStringView{value}.split(u'|');
+        for (const auto &fullVersion : fullVersions) {
+            const auto parts = fullVersion.split(u',');
+            const QString package = parts.size() == 1
+                                    ? u"*"_s : parts.constFirst().toString();
+            const QString version = parts.constLast().toString();
+            if (!TypeDatabase::setApiVersion(package, version))
+                throw Exception(msgInvalidVersion(package, version));
+        }
+        return true;
+    }
+
+    if (key == u"drop-type-entries") {
+        m_options->m_dropTypeEntries = value.split(u';');
+        m_options->m_dropTypeEntries.sort();
+        return true;
+    }
+
+    if (key == u"keywords") {
+        m_options->m_typesystemKeywords = value.split(u',');
+        return true;
+    }
+
+    if (key == u"typesystem-paths") {
+        m_options->m_typesystemPaths += value.split(QDir::listSeparator(),
+                                                    Qt::SkipEmptyParts);
+        return true;
+    }
+
+    if (key == u"force-process-system-include-paths") {
+        m_options->m_forceProcessSystemIncludes += value.split(QDir::listSeparator(),
+                                                               Qt::SkipEmptyParts);
+        return true;
+    }
+
+    if (source == OptionSource::ProjectFile) {
+        if (key == u"typesystem-path") {
+            m_options->m_typesystemPaths += value;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+struct TypeDatabasePrivate : public TypeDatabaseOptions
 {
     TypeSystemTypeEntryCPtr defaultTypeSystemType() const;
     TypeEntryPtr findType(const QString &name) const;
@@ -128,11 +252,12 @@ struct TypeDatabasePrivate
                                           const CustomTypeEntryPtr &targetLang);
     void addBuiltInPrimitiveTypes();
     void addBuiltInContainerTypes(const TypeDatabaseParserContextPtr &context);
+    bool addOpaqueContainers(const TypeDatabaseParserContextPtr &context);
     TypeEntryMultiMapConstIteratorRange findTypeRange(const QString &name) const;
     template <class Predicate>
     TypeEntryCList findTypesHelper(const QString &name, Predicate pred) const;
     template <class Type, class Predicate>
-    QList<QSharedPointer<const Type> > findTypesByTypeHelper(Predicate pred) const;
+    QList<std::shared_ptr<const Type> > findTypesByTypeHelper(Predicate pred) const;
     TypeEntryPtr resolveTypeDefEntry(const TypedefEntryPtr &typedefEntry, QString *errorMessage);
     template <class String>
     bool isSuppressedWarningHelper(const String &s) const;
@@ -140,12 +265,11 @@ struct TypeDatabasePrivate
     void formatDebug(QDebug &d) const;
     void formatBuiltinTypes(QDebug &d) const;
 
-    bool m_suppressWarnings = true;
     TypeEntryMultiMap m_entries; // Contains duplicate entries (cf addInlineNamespaceLookups).
     TypeEntryMap m_flagsEntries;
     TypedefEntryMap m_typedefEntries;
     TemplateEntryMap m_templates;
-    QList<QRegularExpression> m_suppressedWarnings;
+    QList<SuppressedWarning> m_suppressedWarnings;
     QList<TypeSystemTypeEntryCPtr > m_typeSystemEntries; // maintain order, default is first.
 
     AddedFunctionList m_globalUserFunctions;
@@ -153,18 +277,22 @@ struct TypeDatabasePrivate
 
     QStringList m_requiredTargetImports;
 
-    QStringList m_typesystemPaths;
-    QStringList m_typesystemKeywords;
     QHash<QString, bool> m_parsedTypesystemFiles;
 
     QList<TypeRejection> m_rejections;
-
-    QStringList m_dropTypeEntries;
-    QStringList m_systemIncludes;
 };
 
+static const char ENV_TYPESYSTEMPATH[] = "TYPESYSTEMPATH";
+
 TypeDatabase::TypeDatabase() : d(new TypeDatabasePrivate)
 {
+    // Environment TYPESYSTEMPATH
+    if (qEnvironmentVariableIsSet(ENV_TYPESYSTEMPATH)) {
+        d->m_typesystemPaths
+            += qEnvironmentVariable(ENV_TYPESYSTEMPATH).split(QDir::listSeparator(),
+                                                              Qt::SkipEmptyParts);
+    }
+
     d->addBuiltInType(TypeEntryPtr(new VoidTypeEntry()));
     d->addBuiltInType(TypeEntryPtr(new VarargsTypeEntry()));
     for (const auto &pt : builtinPythonTypes())
@@ -179,6 +307,11 @@ TypeDatabase::~TypeDatabase()
     delete d;
 }
 
+std::shared_ptr<OptionsParser> TypeDatabase::createOptionsParser()
+{
+    return std::make_shared<TypeDatabaseOptionsParser>(d);
+}
+
 TypeDatabase *TypeDatabase::instance(bool newInstance)
 {
     static TypeDatabase *db = nullptr;
@@ -205,12 +338,11 @@ static const IntTypeNormalizationEntries &intTypeNormalizationEntries()
     static bool firstTime = true;
     if (firstTime) {
         firstTime = false;
-        for (auto t : {"char", "short", "int", "long"}) {
-            const QString intType = QLatin1StringView(t);
+        for (const auto &intType : {"char"_L1, "short"_L1, "int"_L1, "long"_L1}) {
             if (!TypeDatabase::instance()->findType(u'u' + intType)) {
                 IntTypeNormalizationEntry entry;
-                entry.replacement = QStringLiteral("unsigned ") + intType;
-                entry.regex.setPattern(QStringLiteral("\\bu") + intType + QStringLiteral("\\b"));
+                entry.replacement = "unsigned "_L1 + intType;
+                entry.regex.setPattern("\\bu"_L1 + intType + "\\b"_L1);
                 Q_ASSERT(entry.regex.isValid());
                 result.append(entry);
             }
@@ -296,26 +428,11 @@ void TypeDatabase::addRequiredTargetImport(const QString& moduleName)
         d->m_requiredTargetImports << moduleName;
 }
 
-void TypeDatabase::addTypesystemPath(const QString& typesystem_paths)
-{
-    #if defined(Q_OS_WIN32)
-    const char path_splitter = ';';
-    #else
-    const char path_splitter = ':';
-    #endif
-    d->m_typesystemPaths += typesystem_paths.split(QLatin1Char(path_splitter));
-}
-
-void TypeDatabase::setTypesystemKeywords(const QStringList &keywords)
-{
-    d->m_typesystemKeywords = keywords;
-}
-
 QStringList TypeDatabase::typesystemKeywords() const
 {
     QStringList result = d->m_typesystemKeywords;
     for (const auto &d : d->m_dropTypeEntries)
-        result.append(QStringLiteral("no_") + d);
+        result.append("no_"_L1 + d);
 
     switch (clang::emulatedCompilerLanguageLevel()) {
     case LanguageLevel::Cpp11:
@@ -339,17 +456,17 @@ QStringList TypeDatabase::typesystemKeywords() const
 IncludeList TypeDatabase::extraIncludes(const QString& className) const
 {
     auto typeEntry = findComplexType(className);
-    return typeEntry.isNull() ? IncludeList() : typeEntry->extraIncludes();
+    return typeEntry ? typeEntry->extraIncludes() :  IncludeList();
 }
 
-const QStringList &TypeDatabase::systemIncludes() const
+const QStringList &TypeDatabase::forceProcessSystemIncludes() const
 {
-    return d->m_systemIncludes;
+    return d->m_forceProcessSystemIncludes;
 }
 
-void TypeDatabase::addSystemInclude(const QString &name)
+void TypeDatabase::addForceProcessSystemInclude(const QString &name)
 {
-    d->m_systemIncludes.append(name);
+    d->m_forceProcessSystemIncludes.append(name);
 }
 
 // Add a lookup for the short name excluding inline namespaces
@@ -370,20 +487,20 @@ ContainerTypeEntryPtr TypeDatabase::findContainerType(const QString &name) const
 {
     QString template_name = name;
 
-    int pos = name.indexOf(u'<');
+    const auto pos = name.indexOf(u'<');
     if (pos > 0)
         template_name = name.left(pos);
 
     auto type_entry = findType(template_name);
     if (type_entry && type_entry->isContainer())
-        return qSharedPointerCast<ContainerTypeEntry>(type_entry);
+        return std::static_pointer_cast<ContainerTypeEntry>(type_entry);
     return {};
 }
 
 static bool inline useType(const TypeEntryCPtr &t)
 {
     return !t->isPrimitive()
-        || qSharedPointerCast<const PrimitiveTypeEntry>(t)->preferredTargetLangType();
+        || std::static_pointer_cast<const PrimitiveTypeEntry>(t)->preferredTargetLangType();
 }
 
 FunctionTypeEntryPtr TypeDatabase::findFunctionType(const QString &name) const
@@ -391,7 +508,7 @@ FunctionTypeEntryPtr TypeDatabase::findFunctionType(const QString &name) const
     const auto entries = d->findTypeRange(name);
     for (const TypeEntryPtr &entry : entries) {
         if (entry->type() == TypeEntry::FunctionType && useType(entry))
-            return qSharedPointerCast<FunctionTypeEntry>(entry);
+            return std::static_pointer_cast<FunctionTypeEntry>(entry);
     }
     return {};
 }
@@ -415,6 +532,17 @@ TypeSystemTypeEntryCPtr TypeDatabase::defaultTypeSystemType() const
     return d->defaultTypeSystemType();
 }
 
+QString TypeDatabase::loadedTypeSystemNames() const
+{
+    QString result;
+    for (const auto &entry : d->m_typeSystemEntries) {
+        if (!result.isEmpty())
+            result += u", "_s;
+        result += entry->name();
+    }
+    return result;
+}
+
 TypeSystemTypeEntryCPtr TypeDatabasePrivate::defaultTypeSystemType() const
 {
     return m_typeSystemEntries.value(0, nullptr);
@@ -454,12 +582,12 @@ TypeEntryCList TypeDatabasePrivate::findTypesHelper(const QString &name, Predica
 }
 
 template<class Type, class Predicate>
-QList<QSharedPointer<const Type> > TypeDatabasePrivate::findTypesByTypeHelper(Predicate pred) const
+QList<std::shared_ptr<const Type> > TypeDatabasePrivate::findTypesByTypeHelper(Predicate pred) const
 {
-    QList<QSharedPointer<const Type> > result;
+    QList<std::shared_ptr<const Type> > result;
     for (const auto &entry : m_entries) {
         if (pred(entry))
-            result.append(qSharedPointerCast<const Type>(entry));
+            result.append(std::static_pointer_cast<const Type>(entry));
     }
     return result;
 }
@@ -559,6 +687,7 @@ bool TypeDatabase::isClassRejected(const QString& className, QString *reason) co
 {
     for (const TypeRejection& r : d->m_rejections) {
         if (r.matchType == TypeRejection::ExcludeClass && r.className.match(className).hasMatch()) {
+            r.matched = true;
             if (reason)
                 *reason = msgRejectReason(r);
             return true;
@@ -577,6 +706,7 @@ static bool findRejection(const QList<TypeRejection> &rejections,
     for (const TypeRejection& r : rejections) {
         if (r.matchType == matchType && r.pattern.match(name).hasMatch()
             && r.className.match(className).hasMatch()) {
+            r.matched = true;
             if (reason)
                 *reason = msgRejectReason(r, name);
             return true;
@@ -594,7 +724,7 @@ TypeEntryPtr TypeDatabasePrivate::resolveTypeDefEntry(const TypedefEntryPtr &typ
                                              QString *errorMessage)
 {
     QString sourceName = typedefEntry->sourceType();
-    const int lessThanPos = sourceName.indexOf(u'<');
+    const auto lessThanPos = sourceName.indexOf(u'<');
     if (lessThanPos != -1)
         sourceName.truncate(lessThanPos);
     ComplexTypeEntryPtr source;
@@ -604,8 +734,8 @@ TypeEntryPtr TypeDatabasePrivate::resolveTypeDefEntry(const TypedefEntryPtr &typ
         case TypeEntry::ContainerType:
         case TypeEntry::ObjectType:
         case TypeEntry::SmartPointerType:
-            source = qSharedPointerDynamicCast<ComplexTypeEntry>(e);
-            Q_ASSERT(!source.isNull());
+            source = std::dynamic_pointer_cast<ComplexTypeEntry>(e);
+            Q_ASSERT(source);
             break;
         default:
             break;
@@ -613,8 +743,7 @@ TypeEntryPtr TypeDatabasePrivate::resolveTypeDefEntry(const TypedefEntryPtr &typ
     }
     if (!source) {
         if (errorMessage)
-            *errorMessage = u"Unable to resolve typedef \""_s
-                            + typedefEntry->sourceType() + u'"';
+            *errorMessage = msgUnableToResolveTypedef(typedefEntry->sourceType(), sourceName);
         return nullptr;
     }
 
@@ -641,8 +770,8 @@ bool TypeDatabase::addType(const TypeEntryPtr &e, QString *errorMessage)
 bool TypeDatabasePrivate::addType(TypeEntryPtr e, QString *errorMessage)
 {
     if (e->type() == TypeEntry::TypedefType) {
-        e = resolveTypeDefEntry(qSharedPointerCast<TypedefEntry>(e), errorMessage);
-        if (Q_UNLIKELY(e.isNull()))
+        e = resolveTypeDefEntry(std::static_pointer_cast<TypedefEntry>(e), errorMessage);
+        if (Q_UNLIKELY(!e))
             return false;
     }
     m_entries.insert(e->qualifiedCppName(), e);
@@ -654,7 +783,7 @@ ConstantValueTypeEntryPtr
     TypeDatabase::addConstantValueTypeEntry(const QString &value,
                                             const TypeEntryCPtr &parent)
 {
-    ConstantValueTypeEntryPtr result(new ConstantValueTypeEntry(value, parent));
+    auto result = std::make_shared<ConstantValueTypeEntry>(value, parent);
     result->setCodeGeneration(TypeEntry::GenerateNothing);
     addType(result);
     return result;
@@ -687,7 +816,7 @@ bool TypeDatabase::isReturnTypeRejected(const QString& className, const QString&
 FlagsTypeEntryPtr TypeDatabase::findFlagsType(const QString &name) const
 {
     TypeEntryPtr fte = findType(name);
-    if (fte.isNull()) {
+    if (!fte) {
         fte = d->m_flagsEntries.value(name);
         if (!fte) {
             //last hope, search for flag without scope  inside of flags hash
@@ -700,10 +829,10 @@ FlagsTypeEntryPtr TypeDatabase::findFlagsType(const QString &name) const
             }
         }
     }
-    return qSharedPointerCast<FlagsTypeEntry>(fte);
+    return std::static_pointer_cast<FlagsTypeEntry>(fte);
 }
 
-void TypeDatabase::addFlagsType(FlagsTypeEntryPtr fte)
+void TypeDatabase::addFlagsType(const FlagsTypeEntryPtr &fte)
 {
     d->m_flagsEntries[fte->originalName()] = fte;
 }
@@ -720,7 +849,7 @@ void TypeDatabase::addTemplate(const TemplateEntryPtr &t)
 
 void TypeDatabase::addTemplate(const QString &name, const QString &code)
 {
-    TemplateEntryPtr te(new TemplateEntry(name));
+    auto te = std::make_shared<TemplateEntry>(name);
     te->addCode(code);
     addTemplate(te);
 }
@@ -767,12 +896,8 @@ FunctionModificationList
     return lst;
 }
 
-void TypeDatabase::setSuppressWarnings(bool on)
-{
-    d->m_suppressWarnings = on;
-}
-
-bool TypeDatabase::addSuppressedWarning(const QString &warning, QString *errorMessage)
+bool TypeDatabase::addSuppressedWarning(const QString &warning, bool generate,
+                                        QString *errorMessage)
 {
     QString pattern;
     if (warning.startsWith(u'^') && warning.endsWith(u'$')) {
@@ -793,7 +918,7 @@ bool TypeDatabase::addSuppressedWarning(const QString &warning, QString *errorMe
         qsizetype lastPos = 0;
         for (qsizetype a = 0, aSize = asteriskPositions.size(); a < aSize; ++a) {
             if (a)
-                pattern.append(QStringLiteral(".*"));
+                pattern.append(".*"_L1);
             const auto nextPos = asteriskPositions.at(a);
             if (nextPos > lastPos)
                 pattern.append(QRegularExpression::escape(warning.mid(lastPos, nextPos - lastPos)));
@@ -810,7 +935,7 @@ bool TypeDatabase::addSuppressedWarning(const QString &warning, QString *errorMe
     }
     expression.setPatternOptions(expression.patternOptions() | QRegularExpression::MultilineOption);
 
-    d->m_suppressedWarnings.append(expression);
+    d->m_suppressedWarnings.append({expression, warning, generate});
     return true;
 }
 
@@ -818,10 +943,14 @@ bool TypeDatabase::isSuppressedWarning(QStringView s) const
 {
     if (!d->m_suppressWarnings)
         return false;
-    return std::any_of(d->m_suppressedWarnings.cbegin(), d->m_suppressedWarnings.cend(),
-                       [&s] (const QRegularExpression &e) {
-                           return e.match(s).hasMatch();
-                       });
+    auto wit = std::find_if(d->m_suppressedWarnings.cbegin(), d->m_suppressedWarnings.cend(),
+                            [&s] (const SuppressedWarning &e) {
+                                return e.pattern.matchView(s).hasMatch();
+                            });
+    const bool found = wit != d->m_suppressedWarnings.cend();
+    if (found)
+        wit->matched = true;
+    return found;
 }
 
 QString TypeDatabase::modifiedTypesystemFilepath(const QString& tsFile, const QString &currentPath) const
@@ -829,6 +958,27 @@ QString TypeDatabase::modifiedTypesystemFilepath(const QString& tsFile, const QS
     return d->modifiedTypesystemFilepath(tsFile, currentPath);
 }
 
+void TypeDatabase::logUnmatched() const
+{
+    for (auto &sw : d->m_suppressedWarnings) {
+        if (sw.generate && !sw.matched)
+            qWarning("Unmatched suppressed warning: \"%s\"", qPrintable(sw.rawText));
+    }
+
+    for (auto &tr : d->m_rejections) {
+        if (tr.generate && !tr.matched) {
+            QDebug d = qWarning();
+            d.noquote();
+            d.nospace();
+            d << "Unmatched rejection: " << tr.matchType;
+            if (!tr.className.pattern().isEmpty())
+                d << " class " << tr.className.pattern();
+            if (!tr.pattern.pattern().isEmpty())
+                d << " \"" << tr.pattern.pattern() << '"';
+        }
+    }
+}
+
 QString TypeDatabasePrivate::modifiedTypesystemFilepath(const QString& tsFile,
                                                         const QString &currentPath) const
 {
@@ -854,16 +1004,25 @@ void TypeDatabasePrivate::addBuiltInContainerTypes(const TypeDatabaseParserConte
 {
     // Unless the user has added the standard containers (potentially with
     // some opaque types), add them by default.
+    const bool hasStdArray = findType(u"std::array"_s) != nullptr;
     const bool hasStdPair = findType(u"std::pair"_s) != nullptr;
     const bool hasStdList = findType(u"std::list"_s) != nullptr;
     const bool hasStdVector = findType(u"std::vector"_s) != nullptr;
     const bool hasStdMap = findType(u"std::map"_s) != nullptr;
     const bool hasStdUnorderedMap = findType(u"std::unordered_map"_s) != nullptr;
+    const bool hasStdSpan = findType(u"std::span"_s) != nullptr;
 
     if (hasStdPair && hasStdList && hasStdVector && hasStdMap && hasStdUnorderedMap)
         return;
 
     QByteArray ts = R"(<?xml version="1.0" encoding="UTF-8"?><typesystem>)";
+    if (!hasStdArray) {
+        ts += containerTypeSystemSnippet(
+            "std::array", "list", "array",
+            "shiboken_conversion_cppsequence_to_pylist",
+            "PySequence",
+            "shiboken_conversion_pyiterable_to_cpparray");
+    }
     if (!hasStdPair) {
         ts += containerTypeSystemSnippet(
                   "std::pair", "pair", "utility",
@@ -896,6 +1055,16 @@ void TypeDatabasePrivate::addBuiltInContainerTypes(const TypeDatabaseParserConte
                   "shiboken_conversion_stdmap_to_pydict",
                   "PyDict", "shiboken_conversion_pydict_to_stdmap");
     }
+    if (!hasStdSpan
+        && clang::emulatedCompilerLanguageLevel() >= LanguageLevel::Cpp20) {
+        auto spanSnip = containerTypeSystemSnippet(
+                            "std::span", "span", "span",
+                            "shiboken_conversion_cppsequence_to_pylist");
+        auto pos = spanSnip.indexOf('>');
+        spanSnip.insert(pos, R"( view-on="std::vector")");
+        ts += spanSnip;
+    }
+
     ts += "</typesystem>";
     QBuffer buffer(&ts);
     buffer.open(QIODevice::ReadOnly);
@@ -903,6 +1072,22 @@ void TypeDatabasePrivate::addBuiltInContainerTypes(const TypeDatabaseParserConte
     Q_ASSERT(ok);
 }
 
+bool TypeDatabasePrivate::addOpaqueContainers(const TypeDatabaseParserContextPtr &context)
+{
+    const auto &och = context->opaqueContainerHash;
+    for (auto it = och.cbegin(), end = och.cend(); it != end; ++it) {
+        const QString &name = it.key();
+        auto te = findType(name);
+        if (!te || !te->isContainer()) {
+            qCWarning(lcShiboken, "No container \"%s\" found.", qPrintable(name));
+            return false;
+        }
+        auto cte = std::static_pointer_cast<ContainerTypeEntry>(te);
+        cte->appendOpaqueContainers(it.value());
+    }
+    return true;
+}
+
 bool TypeDatabase::parseFile(const QString &filename, bool generate)
 {
     QString filepath = modifiedTypesystemFilepath(filename, {});
@@ -966,7 +1151,7 @@ bool TypeDatabase::parseFile(QIODevice *device, bool generate)
 
 bool TypeDatabasePrivate::parseFile(QIODevice *device, TypeDatabase *db, bool generate)
 {
-    const TypeDatabaseParserContextPtr context(new TypeDatabaseParserContext);
+    const auto context = std::make_shared<TypeDatabaseParserContext>();
     context->db = db;
 
     if (!parseFile(context, device, generate))
@@ -974,7 +1159,8 @@ bool TypeDatabasePrivate::parseFile(QIODevice *device, TypeDatabase *db, bool ge
 
     addBuiltInPrimitiveTypes();
     addBuiltInContainerTypes(context);
-    return resolveSmartPointerInstantiations(context);
+    return addOpaqueContainers(context)
+        && resolveSmartPointerInstantiations(context);
 }
 
 bool TypeDatabase::parseFile(const TypeDatabaseParserContextPtr &context,
@@ -1067,7 +1253,7 @@ PrimitiveTypeEntryPtr TypeDatabase::findPrimitiveType(const QString& name) const
     const auto entries = d->findTypeRange(name);
     for (const auto &entry : entries) {
         if (entry->isPrimitive()) {
-            auto pe = qSharedPointerCast<PrimitiveTypeEntry>(entry);
+            auto pe = std::static_pointer_cast<PrimitiveTypeEntry>(entry);
             if (pe->preferredTargetLangType())
                 return pe;
         }
@@ -1081,7 +1267,7 @@ ComplexTypeEntryPtr TypeDatabase::findComplexType(const QString& name) const
     const auto entries = d->findTypeRange(name);
     for (const auto &entry : entries) {
         if (entry->isComplex() && useType(entry))
-            return qSharedPointerCast<ComplexTypeEntry>(entry);
+            return std::static_pointer_cast<ComplexTypeEntry>(entry);
     }
     return nullptr;
 }
@@ -1090,8 +1276,8 @@ ObjectTypeEntryPtr TypeDatabase::findObjectType(const QString& name) const
 {
     const auto entries = d->findTypeRange(name);
     for (const auto &entry : entries) {
-        if (!entry.isNull() && entry->isObject() && useType(entry))
-            return qSharedPointerCast<ObjectTypeEntry>(entry);
+        if (entry && entry->isObject() && useType(entry))
+            return std::static_pointer_cast<ObjectTypeEntry>(entry);
     }
     return nullptr;
 }
@@ -1102,7 +1288,7 @@ NamespaceTypeEntryList TypeDatabase::findNamespaceTypes(const QString& name) con
     const auto entries = d->findTypeRange(name);
     for (const auto &entry : entries) {
         if (entry->isNamespace())
-            result.append(qSharedPointerCast<NamespaceTypeEntry>(entry));
+            result.append(std::static_pointer_cast<NamespaceTypeEntry>(entry));
     }
     return result;
 }
@@ -1130,7 +1316,7 @@ bool TypeDatabase::shouldDropTypeEntry(const QString& fullTypeName) const
     return d->m_dropTypeEntries.contains(fullTypeName);
 }
 
-void TypeDatabase::setDropTypeEntries(QStringList dropTypeEntries)
+void TypeDatabase::setDropTypeEntries(const QStringList &dropTypeEntries)
 {
     d->m_dropTypeEntries = dropTypeEntries;
     d->m_dropTypeEntries.sort();
@@ -1157,7 +1343,7 @@ static void _computeTypeIndexes()
     const auto &allEntries = tdb->entries();
     list.reserve(allEntries.size());
     for (auto  tit = allEntries.cbegin(), end = allEntries.cend(); tit != end; ++tit) {
-        TypeEntryPtr entry = tit.value();
+        const TypeEntryPtr &entry = tit.value();
         if (entry->isPrimitive()
             || entry->isContainer()
             || entry->isFunction()
@@ -1222,7 +1408,7 @@ bool TypeDatabase::setApiVersion(const QString& packageWildcardPattern, const QS
     const QRegularExpression packageRegex(packagePattern);
     if (!packageRegex.isValid())
         return false;
-    versions.append(qMakePair(packageRegex, versionNumber));
+    versions.append(std::make_pair(packageRegex, versionNumber));
     return true;
 }
 
@@ -1246,21 +1432,6 @@ bool TypeDatabase::hasDroppedTypeEntries() const
 }
 
 #ifndef QT_NO_DEBUG_STREAM
-
-template <class Container, class Separator>
-static void formatList(QDebug &d, const char *name, const Container &c, Separator sep)
-{
-    if (const auto size = c.size()) {
-        d << ", " << name << '[' << size << "]=(";
-        for (qsizetype i = 0; i < size; ++i) {
-            if (i)
-                d << sep;
-             d << c.at(i);
-        }
-        d << ')';
-    }
-}
-
 void TypeDatabase::formatDebug(QDebug &debug) const
 {
     d->formatDebug(debug);
@@ -1303,7 +1474,7 @@ void TypeDatabasePrivate::formatDebug(QDebug &d) const
         d << ")\n";
     }
     d <<"\nglobalUserFunctions=" << m_globalUserFunctions << '\n';
-    formatList(d, "globalFunctionMods", m_functionMods, '\n');
+    formatList(d, "globalFunctionMods", m_functionMods, "\n");
     d << ')';
 }
 
@@ -1368,9 +1539,9 @@ void TypeDatabase::formatBuiltinTypes(QDebug debug) const
 
     // Determine base types and their typedef'ed types
     QList<PrimitiveFormatListEntry> primitiveEntries;
-    for (auto &e : std::as_const(d->m_entries)) {
+    for (const auto &e : std::as_const(d->m_entries)) {
         if (e->isPrimitive()) {
-            auto pe = qSharedPointerCast<const PrimitiveTypeEntry>(e);
+            auto pe = std::static_pointer_cast<const PrimitiveTypeEntry>(e);
             auto basic = basicReferencedTypeEntry(pe);
             if (basic != pe) {
                 const auto idx = indexOf(primitiveEntries, basic);
@@ -1405,7 +1576,7 @@ PrimitiveTypeEntryPtr
                                           const QString &rootPackage,
                                           const CustomTypeEntryPtr &targetLang)
 {
-    PrimitiveTypeEntryPtr result(new PrimitiveTypeEntry(name, {}, root));
+    auto result = std::make_shared<PrimitiveTypeEntry>(name, QVersionNumber{}, root);
     result->setTargetLangApiType(targetLang);
     result->setTargetLangPackage(rootPackage);
     addBuiltInType(result);
@@ -1433,15 +1604,15 @@ void TypeDatabasePrivate::addBuiltInPrimitiveTypes()
 
     // C++ primitive types
     auto pyLongEntry = findType(u"PyLong"_s);
-    Q_ASSERT(!pyLongEntry.isNull() && pyLongEntry->isCustom());
-    auto pyLongCustomEntry = qSharedPointerCast<CustomTypeEntry>(pyLongEntry);
+    Q_ASSERT(pyLongEntry && pyLongEntry->isCustom());
+    auto pyLongCustomEntry = std::static_pointer_cast<CustomTypeEntry>(pyLongEntry);
     auto pyBoolEntry = findType(u"PyBool"_s);
-    Q_ASSERT(!pyBoolEntry.isNull() && pyBoolEntry->isCustom());
+    Q_ASSERT(pyBoolEntry && pyBoolEntry->isCustom());
     auto sbkCharEntry = findType(u"SbkChar"_s);
-    Q_ASSERT(!sbkCharEntry.isNull() && sbkCharEntry->isCustom());
-    auto sbkCharCustomEntry = qSharedPointerCast<CustomTypeEntry>(sbkCharEntry);
+    Q_ASSERT(sbkCharEntry && sbkCharEntry->isCustom());
+    auto sbkCharCustomEntry = std::static_pointer_cast<CustomTypeEntry>(sbkCharEntry);
 
-    auto pyBoolCustomEntry = qSharedPointerCast<CustomTypeEntry>(pyBoolEntry);
+    auto pyBoolCustomEntry = std::static_pointer_cast<CustomTypeEntry>(pyBoolEntry);
     for (const auto &t : AbstractMetaType::cppIntegralTypes()) {
         if (!m_entries.contains(t)) {
             CustomTypeEntryPtr targetLangApi = pyLongCustomEntry;
@@ -1454,24 +1625,24 @@ void TypeDatabasePrivate::addBuiltInPrimitiveTypes()
     }
 
     auto pyFloatEntry = findType(u"PyFloat"_s);
-    Q_ASSERT(!pyFloatEntry.isNull() && pyFloatEntry->isCustom());
-    auto pyFloatCustomEntry = qSharedPointerCast<CustomTypeEntry>(pyFloatEntry);
+    Q_ASSERT(pyFloatEntry && pyFloatEntry->isCustom());
+    auto pyFloatCustomEntry = std::static_pointer_cast<CustomTypeEntry>(pyFloatEntry);
     for (const auto &t : AbstractMetaType::cppFloatTypes()) {
         if (!m_entries.contains(t))
             addBuiltInPrimitiveType(t, root, rootPackage, pyFloatCustomEntry);
     }
 
     auto pyUnicodeEntry = findType(u"PyUnicode"_s);
-    Q_ASSERT(!pyUnicodeEntry.isNull() && pyUnicodeEntry->isCustom());
-    auto pyUnicodeCustomEntry = qSharedPointerCast<CustomTypeEntry>(pyUnicodeEntry);
+    Q_ASSERT(pyUnicodeEntry && pyUnicodeEntry->isCustom());
+    auto pyUnicodeCustomEntry = std::static_pointer_cast<CustomTypeEntry>(pyUnicodeEntry);
 
-    const QString stdString = u"std::string"_s;
+    constexpr auto stdString = "std::string"_L1;
     if (!m_entries.contains(stdString)) {
         addBuiltInCppStringPrimitiveType(stdString, u"std::string_view"_s,
                                          root, rootPackage,
                                          pyUnicodeCustomEntry);
     }
-    const QString stdWString = u"std::wstring"_s;
+    constexpr auto stdWString = "std::wstring"_L1;
     if (!m_entries.contains(stdWString)) {
         addBuiltInCppStringPrimitiveType(stdWString, u"std::wstring_view"_s,
                                          root, rootPackage,
diff --git a/sources/shiboken6/ApiExtractor/typedatabase.h b/sources/shiboken6/ApiExtractor/typedatabase.h
index 11ed26002..d5adca324 100644
--- a/sources/shiboken6/ApiExtractor/typedatabase.h
+++ b/sources/shiboken6/ApiExtractor/typedatabase.h
@@ -11,10 +11,13 @@
 #include <QtCore/QRegularExpression>
 #include <QtCore/QStringList>
 #include <QtCore/QVersionNumber>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
 
 QT_FORWARD_DECLARE_CLASS(QIODevice)
 
+struct OptionDescription;
+class OptionsParser;
 struct TypeDatabasePrivate;
 struct TypeDatabaseParserContext;
 
@@ -48,7 +51,9 @@ struct TypeRejection
 
     QRegularExpression className;
     QRegularExpression pattern;
-    MatchType matchType;
+    MatchType matchType = ExcludeClass;
+    bool generate; // Current type system
+    mutable bool matched = false;
 };
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -58,10 +63,14 @@ QDebug operator<<(QDebug d, const TypeRejection &r);
 class TypeDatabase
 {
     TypeDatabase();
-    Q_DISABLE_COPY(TypeDatabase)
 public:
+    Q_DISABLE_COPY_MOVE(TypeDatabase)
+
     ~TypeDatabase();
 
+    static QList<OptionDescription> options();
+    std::shared_ptr<OptionsParser> createOptionsParser();
+
     /**
     * Return the type system instance.
     * \param newInstance This parameter is useful just for unit testing, because singletons causes
@@ -76,15 +85,12 @@ public:
 
     void addRequiredTargetImport(const QString &moduleName);
 
-    void addTypesystemPath(const QString &typesystem_paths);
-
-    void setTypesystemKeywords(const QStringList &keywords);
     QStringList typesystemKeywords() const;
 
     IncludeList extraIncludes(const QString &className) const;
 
-    const QStringList &systemIncludes() const;
-    void addSystemInclude(const QString &name);
+    const QStringList &forceProcessSystemIncludes() const;
+    void addForceProcessSystemInclude(const QString &name);
 
     void addInlineNamespaceLookups(const NamespaceTypeEntryCPtr &n);
 
@@ -97,6 +103,7 @@ public:
     FunctionTypeEntryPtr findFunctionType(const QString &name) const;
     TypeSystemTypeEntryCPtr findTypeSystemType(const QString &name) const;
     TypeSystemTypeEntryCPtr defaultTypeSystemType() const;
+    QString loadedTypeSystemNames() const;
     QString defaultPackageName() const;
 
     TypeEntryPtr findType(const QString &name) const;
@@ -135,7 +142,7 @@ public:
                                const ComplexTypeEntryCPtr &source);
 
     FlagsTypeEntryPtr findFlagsType(const QString &name) const;
-    void addFlagsType(FlagsTypeEntryPtr fte);
+    void addFlagsType(const FlagsTypeEntryPtr &fte);
 
     TemplateEntryPtr findTemplate(const QString &name) const;
 
@@ -153,9 +160,7 @@ public:
     FunctionModificationList
         globalFunctionModifications(const QStringList &signatures) const;
 
-    void setSuppressWarnings(bool on);
-
-    bool addSuppressedWarning(const QString &warning, QString *errorMessage);
+    bool addSuppressedWarning(const QString &warning, bool generate, QString *errorMessage);
 
     bool isSuppressedWarning(QStringView s) const;
 
@@ -163,12 +168,12 @@ public:
 
     // Top level file parsing
     bool parseFile(const QString &filename, bool generate = true);
-    bool parseFile(const QSharedPointer<TypeDatabaseParserContext> &context,
+    bool parseFile(const std::shared_ptr<TypeDatabaseParserContext> &context,
                    const QString &filename, const QString &currentPath, bool generate);
 
     // Top level QIODevice parsing for tests.
     bool parseFile(QIODevice *device, bool generate = true);
-    bool parseFile(const QSharedPointer<TypeDatabaseParserContext> &context,
+    bool parseFile(const std::shared_ptr<TypeDatabaseParserContext> &context,
                    QIODevice *device, bool generate = true);
 
     static bool setApiVersion(const QString &package, const QString &version);
@@ -180,10 +185,12 @@ public:
 
     bool shouldDropTypeEntry(const QString &fullTypeName) const;
 
-    void setDropTypeEntries(QStringList dropTypeEntries);
+    void setDropTypeEntries(const QStringList &dropTypeEntries);
 
     QString modifiedTypesystemFilepath(const QString &tsFile, const QString &currentPath = QString()) const;
 
+    void logUnmatched() const;
+
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &d) const;
 #endif
diff --git a/sources/shiboken6/ApiExtractor/typedatabase_p.h b/sources/shiboken6/ApiExtractor/typedatabase_p.h
index 04c1df145..fc56c7961 100644
--- a/sources/shiboken6/ApiExtractor/typedatabase_p.h
+++ b/sources/shiboken6/ApiExtractor/typedatabase_p.h
@@ -5,6 +5,7 @@
 #define TYPEDATABASE_P_H
 
 #include "typesystem_typedefs.h"
+#include "containertypeentry.h"
 
 #include <QtCore/QHash>
 #include <QtCore/QString>
@@ -14,9 +15,11 @@ class TypeDatabase;
 struct TypeDatabaseParserContext
 {
     using SmartPointerInstantiations = QHash<SmartPointerTypeEntryPtr, QString>;
+    using OpaqueContainerHash = QHash<QString, OpaqueContainers>;
 
     TypeDatabase *db;
     SmartPointerInstantiations smartPointerInstantiations;
+    OpaqueContainerHash opaqueContainerHash;
 };
 
 #endif // TYPEDATABASE_P_H
diff --git a/sources/shiboken6/ApiExtractor/typeparser.cpp b/sources/shiboken6/ApiExtractor/typeparser.cpp
index 10f102b08..11d7bf641 100644
--- a/sources/shiboken6/ApiExtractor/typeparser.cpp
+++ b/sources/shiboken6/ApiExtractor/typeparser.cpp
@@ -37,7 +37,7 @@ public:
     {
     }
 
-    Token nextToken(QString *errorMessage = Q_NULLPTR);
+    Token nextToken(QString *errorMessage = nullptr);
     QString identifier() const;
 
     QString msgParseError(const QString &why) const;
@@ -147,8 +147,8 @@ Scanner::Token Scanner::nextToken(QString *errorMessage)
 
 QString Scanner::msgParseError(const QString &why) const
 {
-    return QStringLiteral("TypeParser: Unable to parse \"")
-        + QString(m_chars, m_length) + QStringLiteral("\": ") + why;
+    return "TypeParser: Unable to parse \""_L1
+        + QString(m_chars, m_length) + "\": "_L1 + why;
 }
 
 TypeInfo TypeParser::parse(const QString &str, QString *errorMessage)
@@ -166,7 +166,7 @@ TypeInfo TypeParser::parse(const QString &str, QString *errorMessage)
     Scanner::Token tok = scanner.nextToken(errorMessage);
     while (tok != Scanner::NoToken) {
         if (tok == Scanner::InvalidToken)
-            return TypeInfo();
+            return {};
 
 //         switch (tok) {
 //         case Scanner::StarToken: printf(" - *\n"); break;
@@ -199,12 +199,12 @@ TypeInfo TypeParser::parse(const QString &str, QString *errorMessage)
                 stack.top().setReferenceType(RValueReference);
                 break;
             case RValueReference:
-                const QString message = scanner.msgParseError(QStringLiteral("Too many '&' qualifiers"));
+                const QString message = scanner.msgParseError("Too many '&' qualifiers"_L1);
                 if (errorMessage)
                     *errorMessage = message;
                 else
                     qWarning().noquote().nospace() << message;
-                return TypeInfo();
+                return {};
             }
             break;
         case Scanner::LessThanToken:
@@ -246,12 +246,12 @@ TypeInfo TypeParser::parse(const QString &str, QString *errorMessage)
 
         case Scanner::OpenParenToken: // function pointers not supported
         case Scanner::CloseParenToken: {
-            const QString message = scanner.msgParseError(QStringLiteral("Function pointers are not supported"));
+            const QString message = scanner.msgParseError("Function pointers are not supported"_L1);
             if (errorMessage)
                 *errorMessage = message;
             else
                 qWarning().noquote().nospace() << message;
-            return TypeInfo();
+            return {};
         }
 
         case Scanner::Identifier:
diff --git a/sources/shiboken6/ApiExtractor/typesystem.cpp b/sources/shiboken6/ApiExtractor/typesystem.cpp
index a5f8ad36c..99d42b668 100644
--- a/sources/shiboken6/ApiExtractor/typesystem.cpp
+++ b/sources/shiboken6/ApiExtractor/typesystem.cpp
@@ -5,9 +5,11 @@
 #include "arraytypeentry.h"
 #include "codesnip.h"
 #include "complextypeentry.h"
+#include "configurabletypeentry.h"
 #include "constantvaluetypeentry.h"
 #include "containertypeentry.h"
 #include "customtypenentry.h"
+#include "debughelpers_p.h"
 #include "enumtypeentry.h"
 #include "enumvaluetypeentry.h"
 #include "flagstypeentry.h"
@@ -50,6 +52,11 @@ static QString buildName(const QString &entryName, const TypeEntryCPtr &parent)
 class TypeEntryPrivate
 {
 public:
+    TypeEntryPrivate(const TypeEntryPrivate &) = default; // Enable copy for cloning.
+    TypeEntryPrivate &operator=(const TypeEntryPrivate &) = delete;
+    TypeEntryPrivate(TypeEntryPrivate &&) = delete;
+    TypeEntryPrivate &operator=(TypeEntryPrivate &&) = delete;
+
     explicit TypeEntryPrivate(const QString &entryName, TypeEntry::Type t, const QVersionNumber &vr,
                               const TypeEntryCPtr &parent);
     virtual ~TypeEntryPrivate() = default;
@@ -181,7 +188,7 @@ TypeSystemTypeEntryCPtr typeSystemTypeEntry(TypeEntryCPtr e)
 {
     for (; e; e = e->parent()) {
         if (e->type() == TypeEntry::TypeSystemType)
-            return qSharedPointerCast<const TypeSystemTypeEntry>(e);
+            return std::static_pointer_cast<const TypeSystemTypeEntry>(e);
     }
     return {};
 }
@@ -323,7 +330,7 @@ QString TypeEntryPrivate::shortName() const
         bool foundInlineNamespace = false;
         for (auto p = m_parent; p != nullptr && p->type() != TypeEntry::TypeSystemType; p = p->parent()) {
             if (p->type() == TypeEntry::NamespaceType
-                && qSharedPointerCast<const NamespaceTypeEntry>(p)->isInlineNamespace()) {
+                && std::static_pointer_cast<const NamespaceTypeEntry>(p)->isInlineNamespace()) {
                 foundInlineNamespace = true;
             } else {
                 parents.append(p);
@@ -659,6 +666,9 @@ public:
 
     CodeSnipList m_codeSnips;
     TypeSystem::SnakeCase m_snakeCase = TypeSystem::SnakeCase::Disabled;
+    QString m_subModuleOf;
+    QString m_namespaceBegin;
+    QString m_namespaceEnd;
 };
 
 TypeSystemTypeEntry::TypeSystemTypeEntry(const QString &entryName, const QVersionNumber &vr,
@@ -696,6 +706,42 @@ void TypeSystemTypeEntry::addCodeSnip(const CodeSnip &codeSnip)
     d->m_codeSnips.append(codeSnip);
 }
 
+QString TypeSystemTypeEntry::subModuleOf() const
+{
+    S_D(const TypeSystemTypeEntry);
+    return d->m_subModuleOf;
+}
+
+void TypeSystemTypeEntry::setSubModule(const QString &s)
+{
+    S_D(TypeSystemTypeEntry);
+    d->m_subModuleOf = s;
+}
+
+const QString &TypeSystemTypeEntry::namespaceBegin() const
+{
+    S_D(const TypeSystemTypeEntry);
+    return d->m_namespaceBegin;
+}
+
+void TypeSystemTypeEntry::setNamespaceBegin(const QString &p)
+{
+    S_D(TypeSystemTypeEntry);
+    d->m_namespaceBegin = p;
+}
+
+const QString &TypeSystemTypeEntry::namespaceEnd() const
+{
+    S_D(const TypeSystemTypeEntry);
+    return d->m_namespaceEnd;
+}
+
+void TypeSystemTypeEntry::setNamespaceEnd(const QString &n)
+{
+    S_D(TypeSystemTypeEntry);
+    d->m_namespaceEnd = n;
+}
+
 TypeSystem::SnakeCase TypeSystemTypeEntry::snakeCase() const
 {
     S_D(const TypeSystemTypeEntry);
@@ -892,7 +938,7 @@ PrimitiveTypeEntryCPtr basicReferencedTypeEntry(const PrimitiveTypeEntryCPtr &e)
 PrimitiveTypeEntryCPtr basicReferencedTypeEntry(const TypeEntryCPtr &e)
 {
     Q_ASSERT(e->isPrimitive());
-    return basicReferencedTypeEntry(qSharedPointerCast<const PrimitiveTypeEntry>(e));
+    return basicReferencedTypeEntry(std::static_pointer_cast<const PrimitiveTypeEntry>(e));
 }
 
 PrimitiveTypeEntryCPtr basicReferencedNonBuiltinTypeEntry(const PrimitiveTypeEntryCPtr &e)
@@ -926,7 +972,7 @@ void PrimitiveTypeEntry::setPreferredTargetLangType(bool b)
 bool PrimitiveTypeEntry::hasCustomConversion() const
 {
     S_D(const PrimitiveTypeEntry);
-    return !d->m_customConversion.isNull();
+    return bool(d->m_customConversion);
 }
 
 void PrimitiveTypeEntry::setCustomConversion(const CustomConversionPtr &customConversion)
@@ -952,23 +998,72 @@ PrimitiveTypeEntry::PrimitiveTypeEntry(PrimitiveTypeEntryPrivate *d)
 {
 }
 
-// ----------------- EnumTypeEntry
-class EnumTypeEntryPrivate : public TypeEntryPrivate
+// ----------------- ConfigurableTypeEntry
+
+class ConfigurableTypeEntryPrivate : public TypeEntryPrivate
 {
 public:
     using TypeEntryPrivate::TypeEntryPrivate;
 
+    QString m_configCondition;
+};
+
+ConfigurableTypeEntry::ConfigurableTypeEntry(const QString &entryName, Type t,
+                                             const QVersionNumber &vr,
+                                             const TypeEntryCPtr &parent) :
+    TypeEntry(new ConfigurableTypeEntryPrivate(entryName, t, vr, parent))
+{
+}
+
+ConfigurableTypeEntry::ConfigurableTypeEntry(ConfigurableTypeEntryPrivate *d) :
+    TypeEntry(d)
+{
+}
+
+TypeEntry *ConfigurableTypeEntry::clone() const
+{
+    S_D(const ConfigurableTypeEntry);
+    return new ConfigurableTypeEntry(new ConfigurableTypeEntryPrivate(*d));
+}
+
+QString ConfigurableTypeEntry::configCondition() const
+{
+    S_D(const ConfigurableTypeEntry);
+    return d->m_configCondition;
+}
+
+void ConfigurableTypeEntry::setConfigCondition(const QString &c)
+{
+    S_D(ConfigurableTypeEntry);
+    d->m_configCondition = c;
+    if (!d->m_configCondition.startsWith(u'#'))
+        d->m_configCondition.prepend(u"#if ");
+}
+
+bool ConfigurableTypeEntry::hasConfigCondition() const
+{
+    S_D(const ConfigurableTypeEntry);
+    return !d->m_configCondition.isEmpty();
+}
+
+// ----------------- EnumTypeEntry
+class EnumTypeEntryPrivate : public ConfigurableTypeEntryPrivate
+{
+public:
+    using ConfigurableTypeEntryPrivate::ConfigurableTypeEntryPrivate;
+
     EnumValueTypeEntryCPtr m_nullValue;
     QStringList m_rejectedEnums;
     FlagsTypeEntryPtr m_flags;
     QString m_cppType;
+    QString m_docFile;
     TypeSystem::PythonEnumType m_pythonEnumType = TypeSystem::PythonEnumType::Unspecified;
 };
 
 EnumTypeEntry::EnumTypeEntry(const QString &entryName,
                              const QVersionNumber &vr,
                              const TypeEntryCPtr &parent) :
-    TypeEntry(new EnumTypeEntryPrivate(entryName, EnumType, vr, parent))
+    ConfigurableTypeEntry(new EnumTypeEntryPrivate(entryName, EnumType, vr, parent))
 {
 }
 
@@ -1055,6 +1150,18 @@ QStringList EnumTypeEntry::enumValueRejections() const
     return d->m_rejectedEnums;
 }
 
+QString EnumTypeEntry::docFile() const
+{
+    S_D(const EnumTypeEntry);
+    return d->m_docFile;
+}
+
+void EnumTypeEntry::setDocFile(const QString &df)
+{
+    S_D(EnumTypeEntry);
+    d->m_docFile = df;
+}
+
 TypeEntry *EnumTypeEntry::clone() const
 {
     S_D(const EnumTypeEntry);
@@ -1062,7 +1169,7 @@ TypeEntry *EnumTypeEntry::clone() const
 }
 
 EnumTypeEntry::EnumTypeEntry(EnumTypeEntryPrivate *d) :
-    TypeEntry(d)
+    ConfigurableTypeEntry(d)
 {
 }
 
@@ -1201,13 +1308,13 @@ ConstantValueTypeEntry::ConstantValueTypeEntry(TypeEntryPrivate *d) :
 }
 
 // ----------------- ComplexTypeEntry
-class ComplexTypeEntryPrivate : public TypeEntryPrivate
+class ComplexTypeEntryPrivate : public ConfigurableTypeEntryPrivate
 {
 public:
     ComplexTypeEntryPrivate(const QString &entryName, TypeEntry::Type t,
                             const QVersionNumber &vr,
                             const TypeEntryCPtr &parent) :
-        TypeEntryPrivate(entryName, t, vr, parent),
+        ConfigurableTypeEntryPrivate(entryName, t, vr, parent),
         m_qualifiedCppName(buildName(entryName, parent)),
         m_polymorphicBase(false),
         m_genericClass(false),
@@ -1256,7 +1363,7 @@ public:
 ComplexTypeEntry::ComplexTypeEntry(const QString &entryName, TypeEntry::Type t,
                                    const QVersionNumber &vr,
                                    const TypeEntryCPtr &parent) :
-    TypeEntry(new ComplexTypeEntryPrivate(entryName, t, vr, parent))
+    ConfigurableTypeEntry(new ComplexTypeEntryPrivate(entryName, t, vr, parent))
 {
 }
 
@@ -1686,10 +1793,11 @@ void ComplexTypeEntry::useAsTypedef(const ComplexTypeEntryCPtr &source)
     TypeEntry::useAsTypedef(source);
     d->m_qualifiedCppName = source->qualifiedCppName();
     d->m_targetType = source->targetType();
+    d->m_typeFlags.setFlag(ComplexTypeEntry::Typedef);
 }
 
 ComplexTypeEntry::ComplexTypeEntry(ComplexTypeEntryPrivate *d) :
-    TypeEntry(d)
+    ConfigurableTypeEntry(d)
 {
 }
 
@@ -1777,9 +1885,6 @@ TypedefEntry::TypedefEntry(TypedefEntryPrivate *d) :
 class ContainerTypeEntryPrivate : public ComplexTypeEntryPrivate
 {
 public:
-    using OpaqueContainer = ContainerTypeEntry::OpaqueContainer;
-    using OpaqueContainers = ContainerTypeEntry::OpaqueContainers;
-
     ContainerTypeEntryPrivate(const QString &entryName,
                               ContainerTypeEntry::ContainerKind containerKind,
                               const QVersionNumber &vr,
@@ -1789,11 +1894,11 @@ public:
     {
     }
 
-    OpaqueContainers::const_iterator findOpaqueContainer(const QString &instantiation) const
+    OpaqueContainers::const_iterator findOpaqueContainer(const QStringList &instantiations) const
     {
         return std::find_if(m_opaqueContainers.cbegin(), m_opaqueContainers.cend(),
-                            [&instantiation](const OpaqueContainer &r) {
-                                return r.instantiation == instantiation;
+                            [&instantiations](const OpaqueContainer &r) {
+                                return r.instantiations == instantiations;
                             });
     }
 
@@ -1802,6 +1907,19 @@ public:
     ContainerTypeEntry::ContainerKind m_containerKind;
 };
 
+QString OpaqueContainer::templateParameters() const
+{
+    QString result;
+    result += u'<';
+    for (qsizetype i = 0, size = instantiations.size(); i < size; ++i) {
+        if (i)
+            result += u',';
+        result += instantiations.at(i);
+    }
+    result += u'>';
+    return result;
+}
+
 ContainerTypeEntry::ContainerTypeEntry(const QString &entryName, ContainerKind containerKind,
                                        const QVersionNumber &vr,
                                        const TypeEntryCPtr &parent) :
@@ -1816,40 +1934,53 @@ ContainerTypeEntry::ContainerKind ContainerTypeEntry::containerKind() const
     return d->m_containerKind;
 }
 
-const ContainerTypeEntry::OpaqueContainers &ContainerTypeEntry::opaqueContainers() const
+qsizetype ContainerTypeEntry::templateParameterCount() const
+{
+    S_D(const ContainerTypeEntry);
+    qsizetype result = 1;
+    switch (d->m_containerKind) {
+    case MapContainer:
+    case MultiMapContainer:
+    case PairContainer:
+    case SpanContainer:
+        result = 2;
+        break;
+    case ListContainer:
+    case SetContainer:
+        break;
+    }
+    return result;
+}
+
+const OpaqueContainers &ContainerTypeEntry::opaqueContainers() const
 {
     S_D(const ContainerTypeEntry);
     return d->m_opaqueContainers;
 }
 
-void ContainerTypeEntry::addOpaqueContainer(OpaqueContainer r)
+void ContainerTypeEntry::appendOpaqueContainers(const OpaqueContainers &l)
 {
     S_D(ContainerTypeEntry);
-    // Fix to match AbstractMetaType::signature() which is used for matching
-    // "Foo*" -> "Foo *"
-    const auto asteriskPos = r.instantiation.indexOf(u'*');
-    if (asteriskPos > 0 && !r.instantiation.at(asteriskPos - 1).isSpace())
-        r.instantiation.insert(asteriskPos, u' ');
-    d->m_opaqueContainers.append(r);
+    d->m_opaqueContainers.append(l);
 }
 
-bool ContainerTypeEntry::generateOpaqueContainer(const QString &instantiation) const
+bool ContainerTypeEntry::generateOpaqueContainer(const QStringList &instantiations) const
 {
     S_D(const ContainerTypeEntry);
-    return d->findOpaqueContainer(instantiation) != d->m_opaqueContainers.cend();
+    return d->findOpaqueContainer(instantiations) != d->m_opaqueContainers.cend();
 }
 
-QString ContainerTypeEntry::opaqueContainerName(const QString &instantiation) const
+QString ContainerTypeEntry::opaqueContainerName(const QStringList &instantiations) const
 {
     S_D(const ContainerTypeEntry);
-    const auto it = d->findOpaqueContainer(instantiation);
+    const auto it = d->findOpaqueContainer(instantiations);
     return it != d->m_opaqueContainers.cend() ? it->name : QString{};
 }
 
 bool ContainerTypeEntry::hasCustomConversion() const
 {
     S_D(const ContainerTypeEntry);
-    return !d->m_customConversion.isNull();
+    return bool(d->m_customConversion);
 }
 
 void ContainerTypeEntry::setCustomConversion(const CustomConversionPtr &customConversion)
@@ -2130,7 +2261,7 @@ void NamespaceTypeEntry::setInlineNamespace(bool i)
 
 bool NamespaceTypeEntry::isVisibleScope(const TypeEntryCPtr &e)
 {
-    return isVisibleScope(e.data());
+    return isVisibleScope(e.get());
 }
 
 bool NamespaceTypeEntry::isVisibleScope(const TypeEntry *e)
@@ -2171,7 +2302,7 @@ ValueTypeEntry::ValueTypeEntry(const QString &entryName, const QVersionNumber &v
 bool ValueTypeEntry::hasCustomConversion() const
 {
     S_D(const ValueTypeEntry);
-    return !d->m_customConversion.isNull();
+    return bool(d->m_customConversion);
 }
 
 void ValueTypeEntry::setCustomConversion(const CustomConversionPtr &customConversion)
@@ -2239,7 +2370,7 @@ public:
     }
 
     QStringList m_signatures;
-    TypeSystem::SnakeCase m_snakeCase = TypeSystem::SnakeCase::Unspecified;
+    QString m_docFile;
 };
 
 FunctionTypeEntry::FunctionTypeEntry(const QString &entryName, const QString &signature,
@@ -2267,16 +2398,16 @@ bool FunctionTypeEntry::hasSignature(const QString &signature) const
     return d->m_signatures.contains(signature);
 }
 
-TypeSystem::SnakeCase FunctionTypeEntry::snakeCase() const
+QString FunctionTypeEntry::docFile() const
 {
     S_D(const FunctionTypeEntry);
-    return d->m_snakeCase;
+    return d->m_docFile;
 }
 
-void FunctionTypeEntry::setSnakeCase(TypeSystem::SnakeCase sc)
+void FunctionTypeEntry::setDocFile(const QString &df)
 {
     S_D(FunctionTypeEntry);
-    d->m_snakeCase = sc;
+    d->m_docFile = df;
 }
 
 TypeEntry *FunctionTypeEntry::clone() const
@@ -2322,20 +2453,6 @@ ObjectTypeEntry::ObjectTypeEntry(ComplexTypeEntryPrivate *d) :
     if (!var.isEmpty()) \
          debug << ", " << var.size() << ' '  << name;
 
-template <class Container, class Separator>
-static void formatList(QDebug &d, const char *name, const Container &c, Separator sep)
-{
-    if (const auto size = c.size()) {
-        d << ", " << name << '[' << size << "]=(";
-        for (qsizetype i = 0; i < size; ++i) {
-            if (i)
-                d << sep;
-             d << c.at(i);
-        }
-        d << ')';
-    }
-}
-
 void TypeEntry::formatDebug(QDebug &debug) const
 {
     const QString cppName = qualifiedCppName();
@@ -2368,9 +2485,9 @@ void TypeEntry::formatDebug(QDebug &debug) const
 void PrimitiveTypeEntry::formatDebug(QDebug &debug) const
 {
     TypeEntry::formatDebug(debug);
-    if (auto e = referencedTypeEntry(); !e.isNull()) {
+    if (auto e = referencedTypeEntry()) {
         debug << ", references";
-        for (; e != nullptr; e = e->referencedTypeEntry())
+        for (; e ; e = e->referencedTypeEntry())
             debug << ":\"" << e->qualifiedCppName() <<'"';
     }
 }
@@ -2418,8 +2535,7 @@ void FunctionTypeEntry::formatDebug(QDebug &debug) const
     S_D(const FunctionTypeEntry);
 
     TypeEntry::formatDebug(debug);
-    debug << "signatures=" << d->m_signatures
-          << ", snakeCase=" << int(d->m_snakeCase);
+    debug << "signatures=" << d->m_signatures;
 }
 
 void TypedefEntry::formatDebug(QDebug &debug) const
@@ -2454,18 +2570,23 @@ void NamespaceTypeEntry::formatDebug(QDebug &debug) const
         debug << "[inline]";
 }
 
+QDebug operator<<(QDebug d, const OpaqueContainer &oc)
+{
+    QDebugStateSaver saver(d);
+    d.noquote();
+    d.nospace();
+    d << "OpaqueContainer(\"" << oc.name << "\": " << oc.templateParameters() << ')';
+    return d;
+}
+
 void ContainerTypeEntry::formatDebug(QDebug &debug) const
 {
     S_D(const ContainerTypeEntry);
 
     ComplexTypeEntry::formatDebug(debug);
     debug << ", type=" << d->m_containerKind << '"';
-    if (!d->m_opaqueContainers.isEmpty()) {
-        debug << ", opaque-containers=[";
-        for (const auto &r : d->m_opaqueContainers)
-            debug << r.instantiation << "->" << r.name << ',';
-        debug << ']';
-    }
+    if (!d->m_opaqueContainers.isEmpty())
+        debug << ", opaque-containers=[" << d->m_opaqueContainers << ']';
 }
 
 void SmartPointerTypeEntry::formatDebug(QDebug &debug) const
@@ -2501,7 +2622,7 @@ QDebug operator<<(QDebug d, const TypeEntry *te)
 
 QDebug operator<<(QDebug d, const TypeEntryCPtr &te)
 {
-    d << te.data();
+    d << te.get();
     return d;
 }
 
@@ -2522,7 +2643,7 @@ QDebug operator<<(QDebug d, const TemplateEntry *te)
 
 QDebug operator<<(QDebug d, const TemplateEntryCPtr &te)
 {
-    d << te.data();
+    d << te.get();
     return d;
 }
 #endif // QT_NO_DEBUG_STREAM
diff --git a/sources/shiboken6/ApiExtractor/typesystem_enums.h b/sources/shiboken6/ApiExtractor/typesystem_enums.h
index 81304e6c2..9ecbb08a1 100644
--- a/sources/shiboken6/ApiExtractor/typesystem_enums.h
+++ b/sources/shiboken6/ApiExtractor/typesystem_enums.h
@@ -35,6 +35,7 @@ enum CodeSnipPosition {
     CodeSnipPositionBeginning,
     CodeSnipPositionEnd,
     CodeSnipPositionDeclaration,
+    CodeSnipPositionPyOverride,
     CodeSnipPositionAny
 };
 
diff --git a/sources/shiboken6/ApiExtractor/typesystem_typedefs.h b/sources/shiboken6/ApiExtractor/typesystem_typedefs.h
index ca652252d..5a4e12ff2 100644
--- a/sources/shiboken6/ApiExtractor/typesystem_typedefs.h
+++ b/sources/shiboken6/ApiExtractor/typesystem_typedefs.h
@@ -5,10 +5,12 @@
 #define TYPESYSTEM_TYPEDEFS_H
 
 #include <QtCore/QList>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
 
 class ArrayTypeEntry;
 class ComplexTypeEntry;
+class ConfigurableTypeEntry;
 class ConstantValueTypeEntry;
 class ContainerTypeEntry;
 class CustomTypeEntry;
@@ -26,44 +28,47 @@ class TypedefEntry;
 class TypeSystemTypeEntry;
 class ValueTypeEntry;
 
-using ArrayTypeEntryPtr = QSharedPointer<ArrayTypeEntry>;
-using ComplexTypeEntryPtr = QSharedPointer<ComplexTypeEntry>;
-using ConstantValueTypeEntryPtr = QSharedPointer<ConstantValueTypeEntry>;
-using ContainerTypeEntryPtr = QSharedPointer<ContainerTypeEntry>;
-using CustomTypeEntryPtr = QSharedPointer<CustomTypeEntry>;
-using EnumTypeEntryPtr = QSharedPointer<EnumTypeEntry>;
-using EnumValueTypeEntryPtr = QSharedPointer<EnumValueTypeEntry>;
-using FlagsTypeEntryPtr = QSharedPointer<FlagsTypeEntry>;
-using FunctionTypeEntryPtr = QSharedPointer<FunctionTypeEntry>;
-using NamespaceTypeEntryPtr = QSharedPointer<NamespaceTypeEntry>;
-using ObjectTypeEntryPtr = QSharedPointer<ObjectTypeEntry>;
-using PrimitiveTypeEntryPtr = QSharedPointer<PrimitiveTypeEntry>;
-using SmartPointerTypeEntryPtr = QSharedPointer<SmartPointerTypeEntry>;
-using TemplateEntryPtr = QSharedPointer<TemplateEntry>;
-using TypeEntryPtr = QSharedPointer<TypeEntry>;
-using TypedefEntryPtr = QSharedPointer<TypedefEntry>;
-using TypeSystemTypeEntryPtr = QSharedPointer<TypeSystemTypeEntry>;
-using ValueTypeEntryPtr = QSharedPointer<ValueTypeEntry>;
+using ArrayTypeEntryPtr = std::shared_ptr<ArrayTypeEntry>;
+using ComplexTypeEntryPtr = std::shared_ptr<ComplexTypeEntry>;
+using ConfigurableTypeEntryPtr = std::shared_ptr<ConfigurableTypeEntry>;
+using ConstantValueTypeEntryPtr = std::shared_ptr<ConstantValueTypeEntry>;
+using ContainerTypeEntryPtr = std::shared_ptr<ContainerTypeEntry>;
+using CustomTypeEntryPtr = std::shared_ptr<CustomTypeEntry>;
+using EnumTypeEntryPtr = std::shared_ptr<EnumTypeEntry>;
+using EnumValueTypeEntryPtr = std::shared_ptr<EnumValueTypeEntry>;
+using FlagsTypeEntryPtr = std::shared_ptr<FlagsTypeEntry>;
+using FunctionTypeEntryPtr = std::shared_ptr<FunctionTypeEntry>;
+using NamespaceTypeEntryPtr = std::shared_ptr<NamespaceTypeEntry>;
+using ObjectTypeEntryPtr = std::shared_ptr<ObjectTypeEntry>;
+using PrimitiveTypeEntryPtr = std::shared_ptr<PrimitiveTypeEntry>;
+using SmartPointerTypeEntryPtr = std::shared_ptr<SmartPointerTypeEntry>;
+using TemplateEntryPtr = std::shared_ptr<TemplateEntry>;
+using TypeEntryPtr = std::shared_ptr<TypeEntry>;
+using TypedefEntryPtr = std::shared_ptr<TypedefEntry>;
+using TypeSystemTypeEntryPtr = std::shared_ptr<TypeSystemTypeEntry>;
+using ValueTypeEntryPtr = std::shared_ptr<ValueTypeEntry>;
 
-using ArrayTypeEntryCPtr = QSharedPointer<const ArrayTypeEntry>;
-using ComplexTypeEntryCPtr = QSharedPointer<const ComplexTypeEntry>;
-using ConstantValueTypeEntryCPtr = QSharedPointer<const ConstantValueTypeEntry>;
-using ContainerTypeEntryCPtr = QSharedPointer<const ContainerTypeEntry>;
-using CustomTypeEntryCPtr = QSharedPointer<const CustomTypeEntry>;
-using EnumTypeEntryCPtr = QSharedPointer<const EnumTypeEntry>;
-using EnumValueTypeEntryCPtr = QSharedPointer<const EnumValueTypeEntry>;
-using FlagsTypeEntryCPtr = QSharedPointer<const FlagsTypeEntry>;
-using FunctionTypeEntryCPtr = QSharedPointer<const FunctionTypeEntry>;
-using NamespaceTypeEntryCPtr = QSharedPointer<const NamespaceTypeEntry>;
-using ObjectTypeEntryCPtr = QSharedPointer<const ObjectTypeEntry>;
-using PrimitiveTypeEntryCPtr = QSharedPointer<const PrimitiveTypeEntry>;
-using SmartPointerTypeEntryCPtr = QSharedPointer<const SmartPointerTypeEntry>;
-using TemplateEntryCPtr = QSharedPointer<const TemplateEntry>;
-using TypeEntryCPtr = QSharedPointer<const TypeEntry>;
-using TypedefEntryCPtr = QSharedPointer<const TypedefEntry>;
-using TypeSystemTypeEntryCPtr = QSharedPointer<const TypeSystemTypeEntry>;
-using ValueTypeEntryCPtr = QSharedPointer<const ValueTypeEntry>;
+using ArrayTypeEntryCPtr = std::shared_ptr<const ArrayTypeEntry>;
+using ComplexTypeEntryCPtr = std::shared_ptr<const ComplexTypeEntry>;
+using ConstantValueTypeEntryCPtr = std::shared_ptr<const ConstantValueTypeEntry>;
+using ConfigurableTypeEntryCPtr = std::shared_ptr<const ConfigurableTypeEntry>;
+using ContainerTypeEntryCPtr = std::shared_ptr<const ContainerTypeEntry>;
+using CustomTypeEntryCPtr = std::shared_ptr<const CustomTypeEntry>;
+using EnumTypeEntryCPtr = std::shared_ptr<const EnumTypeEntry>;
+using EnumValueTypeEntryCPtr = std::shared_ptr<const EnumValueTypeEntry>;
+using FlagsTypeEntryCPtr = std::shared_ptr<const FlagsTypeEntry>;
+using FunctionTypeEntryCPtr = std::shared_ptr<const FunctionTypeEntry>;
+using NamespaceTypeEntryCPtr = std::shared_ptr<const NamespaceTypeEntry>;
+using ObjectTypeEntryCPtr = std::shared_ptr<const ObjectTypeEntry>;
+using PrimitiveTypeEntryCPtr = std::shared_ptr<const PrimitiveTypeEntry>;
+using SmartPointerTypeEntryCPtr = std::shared_ptr<const SmartPointerTypeEntry>;
+using TemplateEntryCPtr = std::shared_ptr<const TemplateEntry>;
+using TypeEntryCPtr = std::shared_ptr<const TypeEntry>;
+using TypedefEntryCPtr = std::shared_ptr<const TypedefEntry>;
+using TypeSystemTypeEntryCPtr = std::shared_ptr<const TypeSystemTypeEntry>;
+using ValueTypeEntryCPtr = std::shared_ptr<const ValueTypeEntry>;
 
+using ComplexTypeEntryCList = QList<ComplexTypeEntryCPtr>;
 using ContainerTypeEntryCList = QList<ContainerTypeEntryCPtr>;
 using NamespaceTypeEntryList = QList<NamespaceTypeEntryPtr>;
 using PrimitiveTypeEntryCList = QList<PrimitiveTypeEntryCPtr>;
diff --git a/sources/shiboken6/ApiExtractor/typesystemparser.cpp b/sources/shiboken6/ApiExtractor/typesystemparser.cpp
index 42edc567a..2b686e997 100644
--- a/sources/shiboken6/ApiExtractor/typesystemparser.cpp
+++ b/sources/shiboken6/ApiExtractor/typesystemparser.cpp
@@ -2,13 +2,13 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "typesystemparser_p.h"
+#include "anystringview_helpers.h"
 #include "addedfunction.h"
 #include "codesnip.h"
 #include "enumtypeentry.h"
 #include "containertypeentry.h"
 #include "customconversion.h"
 #include "customtypenentry.h"
-#include "enumtypeentry.h"
 #include "flagstypeentry.h"
 #include "functiontypeentry.h"
 #include "namespacetypeentry.h"
@@ -46,78 +46,84 @@
 
 using namespace Qt::StringLiterals;
 
-static inline QString allowThreadAttribute() { return QStringLiteral("allow-thread"); }
-static inline QString colonColon() { return QStringLiteral("::"); }
-static inline QString checkFunctionAttribute() { return QStringLiteral("check-function"); }
-static inline QString copyableAttribute() { return QStringLiteral("copyable"); }
-static inline QString accessAttribute() { return QStringLiteral("access"); }
-static inline QString actionAttribute() { return QStringLiteral("action"); }
-static inline QString quoteAfterLineAttribute() { return QStringLiteral("quote-after-line"); }
-static inline QString quoteBeforeLineAttribute() { return QStringLiteral("quote-before-line"); }
-static inline QString textAttribute() { return QStringLiteral("text"); }
-static inline QString nameAttribute() { return QStringLiteral("name"); }
-static inline QString sinceAttribute() { return QStringLiteral("since"); }
-static inline QString untilAttribute() { return QStringLiteral("until"); }
-static inline QString defaultSuperclassAttribute() { return QStringLiteral("default-superclass"); }
-static inline QString deleteInMainThreadAttribute() { return QStringLiteral("delete-in-main-thread"); }
-static inline QString deprecatedAttribute() { return QStringLiteral("deprecated"); }
-static inline QString disableWrapperAttribute() { return QStringLiteral("disable-wrapper"); }
-static inline QString exceptionHandlingAttribute() { return QStringLiteral("exception-handling"); }
-static inline QString extensibleAttribute() { return QStringLiteral("extensible"); }
-static inline QString fileNameAttribute() { return QStringLiteral("file-name"); }
-static inline QString flagsAttribute() { return QStringLiteral("flags"); }
-static inline QString forceAbstractAttribute() { return QStringLiteral("force-abstract"); }
-static inline QString forceIntegerAttribute() { return QStringLiteral("force-integer"); }
-static inline QString formatAttribute() { return QStringLiteral("format"); }
-static inline QString generateUsingAttribute() { return QStringLiteral("generate-using"); }
-static inline QString generateFunctionsAttribute() { return QStringLiteral("generate-functions"); }
-static inline QString classAttribute() { return QStringLiteral("class"); }
-static inline QString generateAttribute() { return QStringLiteral("generate"); }
-static inline QString generateGetSetDefAttribute() { return QStringLiteral("generate-getsetdef"); }
-static inline QString genericClassAttribute() { return QStringLiteral("generic-class"); }
-static inline QString indexAttribute() { return QStringLiteral("index"); }
-static inline QString invalidateAfterUseAttribute() { return QStringLiteral("invalidate-after-use"); }
-static inline QString isNullAttribute() { return QStringLiteral("isNull"); }
-static inline QString locationAttribute() { return QStringLiteral("location"); }
-static inline QString modifiedTypeAttribute() { return QStringLiteral("modified-type"); }
-static inline QString operatorBoolAttribute() { return QStringLiteral("operator-bool"); }
-static inline QString parentManagementAttribute() { return QStringLiteral("parent-management"); }
-static inline QString pyiTypeAttribute() { return QStringLiteral("pyi-type"); }
-static inline QString overloadNumberAttribute() { return QStringLiteral("overload-number"); }
-static inline QString ownershipAttribute() { return QStringLiteral("owner"); }
-static inline QString packageAttribute() { return QStringLiteral("package"); }
-static inline QString positionAttribute() { return QStringLiteral("position"); }
-static inline QString preferredConversionAttribute() { return QStringLiteral("preferred-conversion"); }
-static inline QString preferredTargetLangTypeAttribute() { return QStringLiteral("preferred-target-lang-type"); }
-static inline QString pythonEnumTypeAttribute() { return QStringLiteral("python-type"); }
-static inline QString cppEnumTypeAttribute() { return QStringLiteral("cpp-type"); }
-static inline QString qtMetaTypeAttribute() { return QStringLiteral("qt-register-metatype"); }
-static inline QString removeAttribute() { return QStringLiteral("remove"); }
-static inline QString renameAttribute() { return QStringLiteral("rename"); }
-static inline QString readAttribute() { return QStringLiteral("read"); }
-static inline QString targetLangNameAttribute() { return QStringLiteral("target-lang-name"); }
-static inline QString writeAttribute() { return QStringLiteral("write"); }
-static inline QString opaqueContainerFieldAttribute() { return QStringLiteral("opaque-container"); }
-static inline QString replaceAttribute() { return QStringLiteral("replace"); }
-static inline QString toAttribute() { return QStringLiteral("to"); }
-static inline QString signatureAttribute() { return QStringLiteral("signature"); }
-static inline QString snippetAttribute() { return QStringLiteral("snippet"); }
-static inline QString snakeCaseAttribute() { return QStringLiteral("snake-case"); }
-static inline QString staticAttribute() { return QStringLiteral("static"); }
-static inline QString classmethodAttribute() { return QStringLiteral("classmethod"); }
-static inline QString threadAttribute() { return QStringLiteral("thread"); }
-static inline QString sourceAttribute() { return QStringLiteral("source"); }
-static inline QString streamAttribute() { return QStringLiteral("stream"); }
-static inline QString privateAttribute() { return QStringLiteral("private"); }
-static inline QString xPathAttribute() { return QStringLiteral("xpath"); }
-static inline QString virtualSlotAttribute() { return QStringLiteral("virtual-slot"); }
-static inline QString visibleAttribute() { return QStringLiteral("visible"); }
-static inline QString enumIdentifiedByValueAttribute() { return QStringLiteral("identified-by-value"); }
-
-static inline QString noAttributeValue() { return QStringLiteral("no"); }
-static inline QString yesAttributeValue() { return QStringLiteral("yes"); }
-static inline QString trueAttributeValue() { return QStringLiteral("true"); }
-static inline QString falseAttributeValue() { return QStringLiteral("false"); }
+constexpr auto allowThreadAttribute = "allow-thread"_L1;
+constexpr auto checkFunctionAttribute = "check-function"_L1;
+constexpr auto copyableAttribute = "copyable"_L1;
+constexpr auto accessAttribute = "access"_L1;
+constexpr auto actionAttribute = "action"_L1;
+constexpr auto quoteAfterLineAttribute = "quote-after-line"_L1;
+constexpr auto quoteBeforeLineAttribute = "quote-before-line"_L1;
+constexpr auto textAttribute = "text"_L1;
+constexpr auto nameAttribute = "name"_L1;
+constexpr auto sinceAttribute = "since"_L1;
+constexpr auto untilAttribute = "until"_L1;
+constexpr auto defaultSuperclassAttribute = "default-superclass"_L1;
+constexpr auto deleteInMainThreadAttribute = "delete-in-main-thread"_L1;
+constexpr auto deprecatedAttribute = "deprecated"_L1;
+constexpr auto disableWrapperAttribute = "disable-wrapper"_L1;
+constexpr auto docFileAttribute = "doc-file"_L1;
+constexpr auto exceptionHandlingAttribute = "exception-handling"_L1;
+constexpr auto extensibleAttribute = "extensible"_L1;
+constexpr auto fileNameAttribute = "file-name"_L1;
+constexpr auto fileAttribute = "file"_L1;
+constexpr auto flagsAttribute = "flags"_L1;
+constexpr auto forceAbstractAttribute = "force-abstract"_L1;
+constexpr auto forceIntegerAttribute = "force-integer"_L1;
+constexpr auto formatAttribute = "format"_L1;
+constexpr auto generateUsingAttribute = "generate-using"_L1;
+constexpr auto generateFunctionsAttribute = "generate-functions"_L1;
+constexpr auto classAttribute = "class"_L1;
+constexpr auto generateAttribute = "generate"_L1;
+constexpr auto generateGetSetDefAttribute = "generate-getsetdef"_L1;
+constexpr auto genericClassAttribute = "generic-class"_L1;
+constexpr auto indexAttribute = "index"_L1;
+constexpr auto invalidateAfterUseAttribute = "invalidate-after-use"_L1;
+constexpr auto isNullAttribute = "isNull"_L1;
+constexpr auto locationAttribute = "location"_L1;
+constexpr auto modifiedTypeAttribute = "modified-type"_L1;
+constexpr auto opaqueContainerAttribute = "opaque-containers"_L1;
+constexpr auto operatorBoolAttribute = "operator-bool"_L1;
+constexpr auto parentManagementAttribute = "parent-management"_L1;
+constexpr auto pyiTypeAttribute = "pyi-type"_L1;
+constexpr auto overloadNumberAttribute = "overload-number"_L1;
+constexpr auto ownershipAttribute = "owner"_L1;
+constexpr auto packageAttribute = "package"_L1;
+constexpr auto polymorphicBaseAttribute = "polymorphic-base"_L1;
+constexpr auto positionAttribute = "position"_L1;
+constexpr auto preferredConversionAttribute = "preferred-conversion"_L1;
+constexpr auto preferredTargetLangTypeAttribute = "preferred-target-lang-type"_L1;
+constexpr auto pythonEnumTypeAttribute = "python-type"_L1;
+constexpr auto pythonOverrideAttribute = "python-override"_L1;
+constexpr auto cppEnumTypeAttribute = "cpp-type"_L1;
+constexpr auto qtMetaObjectFunctionsAttribute = "qt-metaobject"_L1;
+constexpr auto qtMetaTypeAttribute = "qt-register-metatype"_L1;
+constexpr auto removeAttribute = "remove"_L1;
+constexpr auto renameAttribute = "rename"_L1;
+constexpr auto readAttribute = "read"_L1;
+constexpr auto targetLangNameAttribute = "target-lang-name"_L1;
+constexpr auto writeAttribute = "write"_L1;
+constexpr auto opaqueContainerFieldAttribute = "opaque-container"_L1;
+constexpr auto replaceAttribute = "replace"_L1;
+constexpr auto toAttribute = "to"_L1;
+constexpr auto signatureAttribute = "signature"_L1;
+constexpr auto snippetAttribute = "snippet"_L1;
+constexpr auto snakeCaseAttribute = "snake-case"_L1;
+constexpr auto staticAttribute = "static"_L1;
+constexpr auto classmethodAttribute = "classmethod"_L1;
+constexpr auto threadAttribute = "thread"_L1;
+constexpr auto sourceAttribute = "source"_L1;
+constexpr auto streamAttribute = "stream"_L1;
+constexpr auto privateAttribute = "private"_L1;
+constexpr auto xPathAttribute = "xpath"_L1;
+constexpr auto virtualSlotAttribute = "virtual-slot"_L1;
+constexpr auto visibleAttribute = "visible"_L1;
+constexpr auto enumIdentifiedByValueAttribute = "identified-by-value"_L1;
+constexpr auto subModuleOfAttribute = "submodule-of"_L1;
+
+constexpr auto noAttributeValue = "no"_L1;
+constexpr auto yesAttributeValue = "yes"_L1;
+constexpr auto trueAttributeValue = "true"_L1;
+constexpr auto falseAttributeValue = "false"_L1;
 
 static bool isTypeEntry(StackElement el)
 {
@@ -147,7 +153,7 @@ static bool setRejectionRegularExpression(const QString &patternIn,
     if (patternIn.startsWith(u'^') && patternIn.endsWith(u'$'))
         pattern = patternIn;
     else if (patternIn == u"*")
-        pattern = QStringLiteral("^.*$");
+        pattern = "^.*$"_L1;
     else
         pattern = u'^' + QRegularExpression::escape(patternIn) + u'$';
     re->setPattern(pattern);
@@ -158,15 +164,20 @@ static bool setRejectionRegularExpression(const QString &patternIn,
     return true;
 }
 
+static inline bool hasFileSnippetAttributes(const QXmlStreamAttributes *attributes)
+{
+    return attributes->hasAttribute(fileAttribute);
+}
+
 // Extract a snippet from a file within annotation "// @snippet label".
 std::optional<QString>
     extractSnippet(const QString &code, const QString &snippetLabel)
 {
     if (snippetLabel.isEmpty())
         return code;
-    const QString pattern = QStringLiteral(R"(^\s*//\s*@snippet\s+)")
+    const QString pattern = R"(^\s*//\s*@snippet\s+)"_L1
         + QRegularExpression::escape(snippetLabel)
-        + QStringLiteral(R"(\s*$)");
+        + R"(\s*$)"_L1;
     const QRegularExpression snippetRe(pattern);
     Q_ASSERT(snippetRe.isValid());
 
@@ -175,7 +186,7 @@ std::optional<QString>
     QString result;
     const auto lines = QStringView{code}.split(u'\n');
     for (const auto &line : lines) {
-        if (snippetRe.match(line).hasMatch()) {
+        if (snippetRe.matchView(line).hasMatch()) {
             foundLabel = true;
             useLine = !useLine;
             if (!useLine)
@@ -188,48 +199,31 @@ std::optional<QString>
     return CodeSnipAbstract::fixSpaces(result);
 }
 
-template <class EnumType, Qt::CaseSensitivity cs = Qt::CaseInsensitive>
+template <class EnumType>
 struct EnumLookup
 {
     QStringView name;
     EnumType value;
 };
 
-template <class EnumType, Qt::CaseSensitivity cs>
-bool operator==(const EnumLookup<EnumType, cs> &e1, const EnumLookup<EnumType, cs> &e2)
-{
-    return e1.name.compare(e2.name, cs) == 0;
-}
-
-template <class EnumType, Qt::CaseSensitivity cs>
-bool operator<(const EnumLookup<EnumType, cs> &e1, const EnumLookup<EnumType, cs> &e2)
-{
-    return e1.name.compare(e2.name, cs) < 0;
-}
-
 // Helper macros to define lookup functions that take a QStringView needle
 // and an optional default return value.
 #define ENUM_LOOKUP_BEGIN(EnumType, caseSensitivity, functionName) \
 static std::optional<EnumType> functionName(QStringView needle) \
 { \
-    using HaystackEntry = EnumLookup<EnumType, caseSensitivity>; \
-    static const HaystackEntry haystack[] =
-
-#define ENUM_LOOKUP_LINEAR_SEARCH() \
-    const auto end = haystack + sizeof(haystack) / sizeof(haystack[0]); \
-    const auto it = std::find(haystack, end, HaystackEntry{needle, {} }); \
+    using HaystackEntry = EnumLookup<EnumType>; \
+    constexpr auto cs = caseSensitivity; \
+    static constexpr HaystackEntry haystack[] =
+
+#define ENUM_LOOKUP_LINEAR_SEARCH \
+    auto pred = [cs, needle](const HaystackEntry &he) { \
+        return he.name.compare(needle, cs) == 0; \
+    }; \
+    auto end = std::cend(haystack); \
+    auto it = std::find_if(std::cbegin(haystack), end, pred); \
     if (it != end) \
         return it->value; \
-    return {}; \
-}
-
-#define ENUM_LOOKUP_BINARY_SEARCH() \
-    const auto end = haystack + sizeof(haystack) / sizeof(haystack[0]); \
-    const HaystackEntry needleEntry{needle, {} }; \
-    const auto lb = std::lower_bound(haystack, end, needleEntry); \
-    if (lb != end && *lb == needleEntry) \
-        return lb->value; \
-    return {}; \
+    return std::nullopt; \
 }
 
 ENUM_LOOKUP_BEGIN(TypeSystem::AllowThread, Qt::CaseInsensitive,
@@ -241,7 +235,7 @@ ENUM_LOOKUP_BEGIN(TypeSystem::AllowThread, Qt::CaseInsensitive,
         {u"no", TypeSystem::AllowThread::Disallow},
         {u"false", TypeSystem::AllowThread::Disallow},
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 
 ENUM_LOOKUP_BEGIN(TypeSystem::BoolCast, Qt::CaseInsensitive,
@@ -252,7 +246,7 @@ ENUM_LOOKUP_BEGIN(TypeSystem::BoolCast, Qt::CaseInsensitive,
         {u"no", TypeSystem::BoolCast::Disabled},
         {u"false", TypeSystem::BoolCast::Disabled},
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(TypeSystem::PythonEnumType, Qt::CaseSensitive,
                   pythonEnumTypeFromAttribute)
@@ -262,7 +256,7 @@ ENUM_LOOKUP_BEGIN(TypeSystem::PythonEnumType, Qt::CaseSensitive,
         {u"Flag", TypeSystem::PythonEnumType::Flag},
         {u"IntFlag", TypeSystem::PythonEnumType::IntFlag},
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(TypeSystem::QtMetaTypeRegistration, Qt::CaseSensitive,
                   qtMetaTypeFromAttribute)
@@ -273,7 +267,7 @@ ENUM_LOOKUP_BEGIN(TypeSystem::QtMetaTypeRegistration, Qt::CaseSensitive,
         {u"no", TypeSystem::QtMetaTypeRegistration::Disabled},
         {u"false", TypeSystem::QtMetaTypeRegistration::Disabled},
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(TypeSystem::Language, Qt::CaseInsensitive,
                   languageFromAttribute)
@@ -283,7 +277,7 @@ ENUM_LOOKUP_BEGIN(TypeSystem::Language, Qt::CaseInsensitive,
         {u"shell", TypeSystem::ShellCode}, // coloca no header, mas antes da declaracao da classe
         {u"target", TypeSystem::TargetLangCode}  // em algum lugar do cpp
     };
-ENUM_LOOKUP_BINARY_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(TypeSystem::Ownership, Qt::CaseInsensitive,
                    ownershipFromFromAttribute)
@@ -292,7 +286,7 @@ ENUM_LOOKUP_BEGIN(TypeSystem::Ownership, Qt::CaseInsensitive,
         {u"c++", TypeSystem::CppOwnership},
         {u"default", TypeSystem::DefaultOwnership}
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(AddedFunction::Access, Qt::CaseInsensitive,
                   addedFunctionAccessFromAttribute)
@@ -300,7 +294,7 @@ ENUM_LOOKUP_BEGIN(AddedFunction::Access, Qt::CaseInsensitive,
         {u"public", AddedFunction::Public},
         {u"protected", AddedFunction::Protected},
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(FunctionModification::ModifierFlag, Qt::CaseSensitive,
                   modifierFromAttribute)
@@ -308,12 +302,11 @@ ENUM_LOOKUP_BEGIN(FunctionModification::ModifierFlag, Qt::CaseSensitive,
         {u"private", FunctionModification::Private},
         {u"public", FunctionModification::Public},
         {u"protected", FunctionModification::Protected},
-        {u"friendly", FunctionModification::Friendly},
         {u"rename", FunctionModification::Rename},
         {u"final", FunctionModification::Final},
         {u"non-final", FunctionModification::NonFinal}
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(ReferenceCount::Action, Qt::CaseInsensitive,
                   referenceCountFromAttribute)
@@ -324,7 +317,7 @@ ENUM_LOOKUP_BEGIN(ReferenceCount::Action, Qt::CaseInsensitive,
         {u"set", ReferenceCount::Set},
         {u"ignore", ReferenceCount::Ignore}
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(ArgumentOwner::Action, Qt::CaseInsensitive,
                   argumentOwnerActionFromAttribute)
@@ -332,16 +325,17 @@ ENUM_LOOKUP_BEGIN(ArgumentOwner::Action, Qt::CaseInsensitive,
         {u"add", ArgumentOwner::Add},
         {u"remove", ArgumentOwner::Remove}
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(TypeSystem::CodeSnipPosition, Qt::CaseInsensitive,
                   codeSnipPositionFromAttribute)
     {
         {u"beginning", TypeSystem::CodeSnipPositionBeginning},
         {u"end", TypeSystem::CodeSnipPositionEnd},
-        {u"declaration", TypeSystem::CodeSnipPositionDeclaration}
+        {u"declaration", TypeSystem::CodeSnipPositionDeclaration},
+        {u"override", TypeSystem::CodeSnipPositionPyOverride}
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(Include::IncludeType, Qt::CaseInsensitive,
                   locationFromAttribute)
@@ -350,7 +344,7 @@ ENUM_LOOKUP_BEGIN(Include::IncludeType, Qt::CaseInsensitive,
         {u"local", Include::LocalPath},
         {u"target", Include::TargetLangImport}
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(TypeSystem::DocModificationMode, Qt::CaseInsensitive,
                   docModificationFromAttribute)
@@ -359,7 +353,7 @@ ENUM_LOOKUP_BEGIN(TypeSystem::DocModificationMode, Qt::CaseInsensitive,
         {u"prepend", TypeSystem::DocModificationPrepend},
         {u"replace", TypeSystem::DocModificationReplace}
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(ContainerTypeEntry::ContainerKind, Qt::CaseSensitive,
                   containerTypeFromAttribute)
@@ -375,9 +369,10 @@ ENUM_LOOKUP_BEGIN(ContainerTypeEntry::ContainerKind, Qt::CaseSensitive,
         {u"multi-map", ContainerTypeEntry::MultiMapContainer},
         {u"hash", ContainerTypeEntry::MapContainer},
         {u"multi-hash", ContainerTypeEntry::MultiMapContainer},
-        {u"pair", ContainerTypeEntry::PairContainer}
+        {u"pair", ContainerTypeEntry::PairContainer},
+        {u"span", ContainerTypeEntry::SpanContainer}
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(TypeRejection::MatchType, Qt::CaseSensitive,
                   typeRejectionFromAttribute)
@@ -389,7 +384,7 @@ ENUM_LOOKUP_BEGIN(TypeRejection::MatchType, Qt::CaseSensitive,
         {u"argument-type", TypeRejection::ArgumentType},
         {u"return-type", TypeRejection::ReturnType}
     };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(TypeSystem::ExceptionHandling, Qt::CaseSensitive,
                   exceptionHandlingFromAttribute)
@@ -401,7 +396,7 @@ ENUM_LOOKUP_BEGIN(TypeSystem::ExceptionHandling, Qt::CaseSensitive,
     {u"yes", TypeSystem::ExceptionHandling::On},
     {u"true", TypeSystem::ExceptionHandling::On},
 };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(TypeSystem::SmartPointerType, Qt::CaseSensitive,
                   smartPointerTypeFromAttribute)
@@ -411,7 +406,7 @@ ENUM_LOOKUP_BEGIN(TypeSystem::SmartPointerType, Qt::CaseSensitive,
     {u"value-handle", TypeSystem::SmartPointerType::ValueHandle},
     {u"shared", TypeSystem::SmartPointerType::Shared}
 };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 template <class EnumType>
 static std::optional<EnumType>
@@ -440,6 +435,7 @@ static const StackElementHash &stackElementHash()
         {u"add-function", StackElement::AddFunction},
         {u"add-pymethoddef", StackElement::AddPyMethodDef},
         {u"array", StackElement::Array},
+        {u"configuration", StackElement::Configuration},
         {u"container-type", StackElement::ContainerTypeEntry},
         {u"conversion-rule", StackElement::ConversionRule},
         {u"custom-constructor", StackElement::Unimplemented},
@@ -465,6 +461,7 @@ static const StackElementHash &stackElementHash()
         {u"native-to-target", StackElement::NativeToTarget},
         {u"no-null-pointer", StackElement::NoNullPointers},
         {u"object-type", StackElement::ObjectTypeEntry},
+        {u"opaque-container", StackElement::OpaqueContainer},
         {u"parent", StackElement::ParentOwner},
         {u"primitive-type", StackElement::PrimitiveTypeEntry},
         {u"property", StackElement::Property},
@@ -520,7 +517,7 @@ ENUM_LOOKUP_BEGIN(TypeSystem::SnakeCase, Qt::CaseSensitive,
     {u"true", TypeSystem::SnakeCase::Enabled},
     {u"both", TypeSystem::SnakeCase::Both},
 };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 ENUM_LOOKUP_BEGIN(TypeSystem::Visibility, Qt::CaseSensitive,
                   visibilityFromAttribute)
@@ -531,10 +528,10 @@ ENUM_LOOKUP_BEGIN(TypeSystem::Visibility, Qt::CaseSensitive,
     {u"yes", TypeSystem::Visibility::Visible},
     {u"true", TypeSystem::Visibility::Visible},
 };
-ENUM_LOOKUP_LINEAR_SEARCH()
+ENUM_LOOKUP_LINEAR_SEARCH
 
 static int indexOfAttribute(const QXmlStreamAttributes &atts,
-                            QStringView name)
+                            QAnyStringView name)
 {
     for (qsizetype i = 0, size = atts.size(); i < size; ++i) {
         if (atts.at(i).qualifiedName() == name)
@@ -602,12 +599,12 @@ QString TypeSystemEntityResolver::readFile(const QString &entityName, QString *e
     path = TypeDatabase::instance()->modifiedTypesystemFilepath(fileName, m_currentPath);
     if (!QFileInfo::exists(path)) {
         *errorMessage = u"Unable to resolve: "_s + entityName;
-        return QString();
+        return {};
     }
     QFile file(path);
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         *errorMessage = msgCannotOpenForReading(file);
-        return QString();
+        return {};
     }
     QString result = QString::fromUtf8(file.readAll()).trimmed();
     // Remove license header comments on which QXmlStreamReader chokes
@@ -647,7 +644,7 @@ enum class ParserState
     Template
 };
 
-TypeSystemParser::TypeSystemParser(const QSharedPointer<TypeDatabaseParserContext> &context,
+TypeSystemParser::TypeSystemParser(const std::shared_ptr<TypeDatabaseParserContext> &context,
                                    bool generate) :
     m_context(context),
     m_generate(generate ? TypeEntry::GenerateCode : TypeEntry::GenerateForSubclass)
@@ -690,7 +687,7 @@ static QString msgReaderError(const ConditionalStreamReader &reader, const QStri
 }
 
 static QString msgUnimplementedElementWarning(const ConditionalStreamReader &reader,
-                                              QStringView name)
+                                              QAnyStringView name)
 {
     QString message;
     QTextStream(&message) << "The element \"" << name
@@ -715,7 +712,7 @@ static inline QString msgUnimplementedAttributeWarning(const ConditionalStreamRe
 
 static QString
     msgUnimplementedAttributeValueWarning(const ConditionalStreamReader &reader,
-                                          QStringView name, QStringView value)
+                                          QAnyStringView name, QAnyStringView value)
 {
     QString message;
     QTextStream(&message) << "The value \"" << value
@@ -732,16 +729,17 @@ static inline
                                                  attribute.value());
 }
 
-static bool addRejection(TypeDatabase *database, QXmlStreamAttributes *attributes,
+static bool addRejection(TypeDatabase *database, bool generate, QXmlStreamAttributes *attributes,
                          QString *errorMessage)
 {
-    const auto classIndex = indexOfAttribute(*attributes, classAttribute());
+    const auto classIndex = indexOfAttribute(*attributes, classAttribute);
     if (classIndex == -1) {
-        *errorMessage = msgMissingAttribute(classAttribute());
+        *errorMessage = msgMissingAttribute(classAttribute);
         return false;
     }
 
     TypeRejection rejection;
+    rejection.generate = generate;
     const QString className = attributes->takeAt(classIndex).value().toString();
     if (!setRejectionRegularExpression(className, &rejection.className, errorMessage))
         return false;
@@ -880,7 +878,7 @@ bool TypeSystemParser::endElement(StackElement element)
                     toNative.setSourceType(m_context->db->findType(toNative.sourceTypeName()));
             }
         }
-        purgeEmptyCodeSnips(&qSharedPointerCast<TypeSystemTypeEntry>(top->entry)->codeSnips());
+        purgeEmptyCodeSnips(&std::static_pointer_cast<TypeSystemTypeEntry>(top->entry)->codeSnips());
         break;
     case StackElement::FunctionTypeEntry:
         TypeDatabase::instance()->addGlobalUserFunctionModifications(top->functionMods);
@@ -892,7 +890,7 @@ bool TypeSystemParser::endElement(StackElement element)
     case StackElement::NamespaceTypeEntry: {
         Q_ASSERT(top->entry);
         Q_ASSERT(top->entry->isComplex());
-        auto centry = qSharedPointerCast<ComplexTypeEntry>(top->entry);
+        auto centry = std::static_pointer_cast<ComplexTypeEntry>(top->entry);
         purgeEmptyCodeSnips(&centry->codeSnips());
         centry->setAddedFunctions(top->addedFunctions);
         centry->setFunctionModifications(top->functionMods);
@@ -902,13 +900,13 @@ bool TypeSystemParser::endElement(StackElement element)
     break;
 
     case StackElement::TypedefTypeEntry: {
-        auto centry = qSharedPointerCast<TypedefEntry>(top->entry)->target();
+        auto centry = std::static_pointer_cast<TypedefEntry>(top->entry)->target();
         centry->setAddedFunctions(centry->addedFunctions() + top->addedFunctions);
         centry->setFunctionModifications(centry->functionModifications() + top->functionMods);
         centry->setFieldModifications(centry->fieldModifications() + top->fieldMods);
         centry->setDocModification(centry->docModifications() + top->docModifications);
         if (top->entry->isComplex()) {
-            auto cte = qSharedPointerCast<const ComplexTypeEntry>(top->entry);
+            auto cte = std::static_pointer_cast<const ComplexTypeEntry>(top->entry);
             centry->setCodeSnips(centry->codeSnips() + cte->codeSnips());
         }
     }
@@ -931,7 +929,7 @@ bool TypeSystemParser::endElement(StackElement element)
         case ParserState::PrimitiveTypeNativeToTargetConversion:
         case ParserState::PrimitiveTypeTargetToNativeConversion: {
             auto customConversion = CustomConversion::getCustomConversion(top->entry);
-            if (customConversion.isNull()) {
+            if (!customConversion) {
                 m_error = msgMissingCustomConversion(top->entry);
                 return false;
             }
@@ -1068,12 +1066,12 @@ CodeSnipAbstract *TypeSystemParser::injectCodeTarget(qsizetype offset) const
     }
     case ParserState::TypeEntryCodeInjection:
         Q_ASSERT(top->entry->isComplex());
-        return &qSharedPointerCast<ComplexTypeEntry>(top->entry)->codeSnips().last();
+        return &std::static_pointer_cast<ComplexTypeEntry>(top->entry)->codeSnips().last();
     case ParserState::TypeSystemCodeInjection:
         Q_ASSERT(top->entry->isTypeSystem());
-        return &qSharedPointerCast<TypeSystemTypeEntry>(top->entry)->codeSnips().last();
+        return &std::static_pointer_cast<TypeSystemTypeEntry>(top->entry)->codeSnips().last();
     case ParserState::Template:
-        return m_templateEntry.data();
+        return m_templateEntry.get();
     default:
         break;
     }
@@ -1122,7 +1120,7 @@ bool TypeSystemParser::characters(const String &ch)
 
 bool TypeSystemParser::importFileElement(const QXmlStreamAttributes &atts)
 {
-    const QString fileName = atts.value(nameAttribute()).toString();
+    const QString fileName = atts.value(nameAttribute).toString();
     if (fileName.isEmpty()) {
         m_error = u"Required attribute 'name' missing for include-file tag."_s;
         return false;
@@ -1137,11 +1135,11 @@ bool TypeSystemParser::importFileElement(const QXmlStreamAttributes &atts)
         }
     }
 
-    const auto quoteFrom = atts.value(quoteAfterLineAttribute());
+    const auto quoteFrom = atts.value(quoteAfterLineAttribute);
     bool foundFromOk = quoteFrom.isEmpty();
     bool from = quoteFrom.isEmpty();
 
-    const auto quoteTo = atts.value(quoteBeforeLineAttribute());
+    const auto quoteTo = atts.value(quoteBeforeLineAttribute);
     bool foundToOk = quoteTo.isEmpty();
     bool to = true;
 
@@ -1161,10 +1159,10 @@ bool TypeSystemParser::importFileElement(const QXmlStreamAttributes &atts)
         }
     }
     if (!foundFromOk || !foundToOk) {
-        QString fromError = QStringLiteral("Could not find quote-after-line='%1' in file '%2'.")
-                                           .arg(quoteFrom.toString(), fileName);
-        QString toError = QStringLiteral("Could not find quote-before-line='%1' in file '%2'.")
-                                         .arg(quoteTo.toString(), fileName);
+        QString fromError = QString::fromLatin1("Could not find quote-after-line='%1' in file '%2'.")
+                                                .arg(quoteFrom.toString(), fileName);
+        QString toError = QString::fromLatin1("Could not find quote-before-line='%1' in file '%2'.")
+                                              .arg(quoteTo.toString(), fileName);
 
         if (!foundToOk)
             m_error = toError;
@@ -1178,29 +1176,27 @@ bool TypeSystemParser::importFileElement(const QXmlStreamAttributes &atts)
     return true;
 }
 
-static bool convertBoolean(QStringView value, const QString &attributeName, bool defaultValue)
+static bool convertBoolean(QStringView value, QAnyStringView attributeName, bool defaultValue)
 {
-    if (value.compare(trueAttributeValue(), Qt::CaseInsensitive) == 0
-        || value.compare(yesAttributeValue(), Qt::CaseInsensitive) == 0) {
+    if (value.compare(trueAttributeValue, Qt::CaseInsensitive) == 0
+        || value.compare(yesAttributeValue, Qt::CaseInsensitive) == 0) {
         return true;
     }
-    if (value.compare(falseAttributeValue(), Qt::CaseInsensitive) == 0
-        || value.compare(noAttributeValue(), Qt::CaseInsensitive) == 0) {
+    if (value.compare(falseAttributeValue, Qt::CaseInsensitive) == 0
+        || value.compare(noAttributeValue, Qt::CaseInsensitive) == 0) {
         return false;
     }
-    const QString warn = QStringLiteral("Boolean value '%1' not supported in attribute '%2'. Use 'yes' or 'no'. Defaulting to '%3'.")
-                                      .arg(value)
-                                      .arg(attributeName,
-                                           defaultValue ? yesAttributeValue() : noAttributeValue());
-
-    qCWarning(lcShiboken).noquote().nospace() << warn;
+    qCWarning(lcShiboken).noquote().nospace() << "Boolean value '" << value
+        << "' not supported in attribute '" << attributeName
+        << "'. Use 'yes' or 'no'. Defaulting to '"
+        << (defaultValue ? yesAttributeValue : noAttributeValue) << "'.";
     return defaultValue;
 }
 
 static bool convertRemovalAttribute(QStringView value)
 {
     return value == u"all" // Legacy
-        || convertBoolean(value, removeAttribute(), false);
+        || convertBoolean(value, removeAttribute, false);
 }
 
 // Check whether an entry should be dropped, allowing for dropping the module
@@ -1226,7 +1222,7 @@ static bool shouldDropTypeEntry(const TypeDatabase *db,
 static QString checkSignatureError(const QString& signature, const QString& tag)
 {
     QString funcName = signature.left(signature.indexOf(u'(')).trimmed();
-    static const QRegularExpression whiteSpace(QStringLiteral("\\s"));
+    static const QRegularExpression whiteSpace("\\s"_L1);
     Q_ASSERT(whiteSpace.isValid());
     if (!funcName.startsWith(u"operator ") && funcName.contains(whiteSpace)) {
         return QString::fromLatin1("Error in <%1> tag signature attribute '%2'.\n"
@@ -1247,7 +1243,7 @@ bool TypeSystemParser::checkRootElement()
 {
     for (auto i = m_contextStack.size() - 1; i >= 0; --i) {
         auto e = m_contextStack.at(i)->entry;
-        if (!e.isNull() && e->isTypeSystem())
+        if (e && e->isTypeSystem())
             return true;
     }
     m_error = msgNoRootTypeSystemEntry();
@@ -1285,7 +1281,7 @@ bool TypeSystemParser::applyCommonAttributes(const ConditionalStreamReader &read
         } else if (name == u"view-on") {
             const QString name = attributes->takeAt(i).value().toString();
             TypeEntryPtr views = findViewedType(name);
-            if (views.isNull()) {
+            if (!views) {
                 m_error = msgCannotFindView(name, type->name());
                 return false;
             }
@@ -1302,10 +1298,10 @@ CustomTypeEntryPtr TypeSystemParser::parseCustomTypeEntry(const ConditionalStrea
 {
     if (!checkRootElement())
         return nullptr;
-    CustomTypeEntryPtr result(new CustomTypeEntry(name, since, m_contextStack.top()->entry));
+    auto result = std::make_shared<CustomTypeEntry>(name, since, m_contextStack.top()->entry);
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == checkFunctionAttribute())
+        if (name == checkFunctionAttribute)
             result->setCheckFunction(attributes->takeAt(i).value().toString());
     }
     return result;
@@ -1320,30 +1316,30 @@ FlagsTypeEntryPtr
 {
     if (!checkRootElement())
         return nullptr;
-    FlagsTypeEntryPtr ftype(new FlagsTypeEntry(u"QFlags<"_s + enumEntry->name() + u'>',
-                                               since,
-                                               typeSystemTypeEntry(currentParentTypeEntry())));
+    auto ftype = std::make_shared<FlagsTypeEntry>(u"QFlags<"_s + enumEntry->name() + u'>',
+                                                  since,
+                                                  typeSystemTypeEntry(currentParentTypeEntry()));
     ftype->setOriginator(enumEntry);
     ftype->setTargetLangPackage(enumEntry->targetLangPackage());
     // Try toenumEntry get the guess the qualified flag name
-    if (!flagName.contains(colonColon())) {
+    if (!flagName.contains(u"::"_s)) {
         auto eq = enumEntry->qualifier();
         if (!eq.isEmpty())
-            flagName.prepend(eq + colonColon());
+            flagName.prepend(eq + u"::"_s);
     }
 
     ftype->setOriginalName(flagName);
     if (!applyCommonAttributes(reader, ftype, attributes))
         return nullptr;
 
-    QStringList lst = flagName.split(colonColon());
+    QStringList lst = flagName.split(u"::"_s);
     const QString name = lst.takeLast();
     const QString targetLangFlagName = lst.join(u'.');
     const QString &targetLangQualifier = enumEntry->targetLangQualifier();
     if (targetLangFlagName != targetLangQualifier) {
-        qCWarning(lcShiboken).noquote().nospace()
-            << QStringLiteral("enum %1 and flags %2 (%3) differ in qualifiers")
-                              .arg(targetLangQualifier, lst.value(0), targetLangFlagName);
+        qCWarning(lcShiboken, "enum %s and flags %s (%s) differ in qualifiers",
+                  qPrintable(targetLangQualifier), qPrintable(lst.value(0)),
+                  qPrintable(targetLangFlagName));
     }
 
     ftype->setFlagsName(name);
@@ -1423,8 +1419,9 @@ SmartPointerTypeEntryPtr
         return nullptr;
     }
 
-    SmartPointerTypeEntryPtr type(new SmartPointerTypeEntry(name, getter, smartPointerType,
-                                                            refCountMethodName, since, currentParentTypeEntry()));
+    auto type = std::make_shared<SmartPointerTypeEntry>(name, getter, smartPointerType,
+                                                        refCountMethodName, since,
+                                                        currentParentTypeEntry());
     if (!applyCommonAttributes(reader, type, attributes))
         return nullptr;
     applyComplexTypeAttributes(reader, type, attributes);
@@ -1442,22 +1439,22 @@ PrimitiveTypeEntryPtr
 {
     if (!checkRootElement())
         return nullptr;
-    PrimitiveTypeEntryPtr type (new PrimitiveTypeEntry(name, since, currentParentTypeEntry()));
+    auto type = std::make_shared<PrimitiveTypeEntry>(name, since, currentParentTypeEntry());
     QString targetLangApiName;
     if (!applyCommonAttributes(reader, type, attributes))
         return nullptr;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == targetLangNameAttribute()) {
+        if (name == targetLangNameAttribute) {
             type->setTargetLangName(attributes->takeAt(i).value().toString());
         } else if (name == u"target-lang-api-name") {
             targetLangApiName = attributes->takeAt(i).value().toString();
-        } else if (name == preferredConversionAttribute()) {
+        } else if (name == preferredConversionAttribute) {
             qCWarning(lcShiboken, "%s",
                       qPrintable(msgUnimplementedAttributeWarning(reader, name)));
-        } else if (name == preferredTargetLangTypeAttribute()) {
+        } else if (name == preferredTargetLangTypeAttribute) {
             const bool v = convertBoolean(attributes->takeAt(i).value(),
-                                          preferredTargetLangTypeAttribute(), true);
+                                          preferredTargetLangTypeAttribute, true);
             type->setPreferredTargetLangType(v);
         } else if (name == u"default-constructor") {
              type->setDefaultConstructor(attributes->takeAt(i).value().toString());
@@ -1466,27 +1463,40 @@ PrimitiveTypeEntryPtr
 
     if (!targetLangApiName.isEmpty()) {
         auto e = m_context->db->findType(targetLangApiName);
-        if (e.isNull() || !e->isCustom()) {
+        if (!e || !e->isCustom()) {
                m_error = msgInvalidTargetLanguageApiName(targetLangApiName);
                return nullptr;
         }
-        type->setTargetLangApiType(qSharedPointerCast<CustomTypeEntry>(e));
+        type->setTargetLangApiType(std::static_pointer_cast<CustomTypeEntry>(e));
     }
     type->setTargetLangPackage(m_defaultPackage);
     return type;
 }
 
 // "int:QList_int;QString:QList_QString"
-static bool parseOpaqueContainers(QStringView s, ContainerTypeEntryPtr cte)
+bool TypeSystemParser::parseOpaqueContainers(QStringView s, OpaqueContainers *result)
 {
     const auto entries = s.split(u';');
     for (const auto &entry : entries) {
         const auto values = entry.split(u':');
-        if (values.size() != 2)
-            return false;
-        QString instantiation = values.at(0).trimmed().toString();
-        QString name = values.at(1).trimmed().toString();
-        cte->addOpaqueContainer({instantiation, name});
+        if (values.size() != 2) {
+            m_error = u"Error parsing the opaque container attribute: \""_s
+                      + s.toString() + u"\"."_s;
+           return false;
+        }
+        OpaqueContainer oc;
+        oc.name = values.at(1).trimmed().toString();
+        const auto instantiations = values.at(0).split(u',', Qt::SkipEmptyParts);
+        for (const auto &instantiationV : instantiations) {
+           QString instantiation = instantiationV.trimmed().toString();
+           // Fix to match AbstractMetaType::signature() which is used for matching
+           // "Foo*" -> "Foo *"
+           const auto asteriskPos = instantiation.indexOf(u'*');
+           if (asteriskPos > 0 && !instantiation.at(asteriskPos - 1).isSpace())
+                instantiation.insert(asteriskPos, u' ');
+           oc.instantiations.append(instantiation);
+        }
+        result->append(oc);
     }
     return true;
 }
@@ -1510,27 +1520,48 @@ ContainerTypeEntryPtr
         return nullptr;
     }
     attributes->removeAt(typeIndex);
-    ContainerTypeEntryPtr type(new ContainerTypeEntry(name, containerTypeOpt.value(),
-                                                      since, currentParentTypeEntry()));
+    auto type = std::make_shared<ContainerTypeEntry>(name, containerTypeOpt.value(),
+                                                     since, currentParentTypeEntry());
     if (!applyCommonAttributes(reader, type, attributes))
         return nullptr;
     applyComplexTypeAttributes(reader, type, attributes);
 
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == u"opaque-containers") {
+        if (name == opaqueContainerAttribute) {
             const auto attribute = attributes->takeAt(i);
-            if (!parseOpaqueContainers(attribute.value(), type)) {
-                m_error = u"Error parsing the opaque container attribute: \""_s
-                          + attribute.value().toString() + u"\"."_s;
+            OpaqueContainers oc;
+            if (!parseOpaqueContainers(attribute.value(), &oc))
                 return nullptr;
-            }
+            type->appendOpaqueContainers(oc);
         }
     }
 
     return type;
 }
 
+bool TypeSystemParser::parseOpaqueContainerElement(QXmlStreamAttributes *attributes)
+{
+    QString containerName;
+    OpaqueContainers oc;
+    for (auto i = attributes->size() - 1; i >= 0; --i) {
+        const auto name = attributes->at(i).qualifiedName();
+        if (name == nameAttribute) {
+            containerName = attributes->takeAt(i).value().toString();
+        } else if (name == opaqueContainerAttribute) {
+            const auto attribute = attributes->takeAt(i);
+            if (!parseOpaqueContainers(attribute.value(), &oc))
+                return false;
+        }
+    }
+    if (containerName.isEmpty()) {
+        m_error = msgMissingAttribute(nameAttribute);
+        return false;
+    }
+    m_context->opaqueContainerHash[containerName].append(oc);
+    return true;
+}
+
 EnumTypeEntryPtr
     TypeSystemParser::parseEnumTypeEntry(const ConditionalStreamReader &reader,
                                 const QString &name, const QVersionNumber &since,
@@ -1538,7 +1569,7 @@ EnumTypeEntryPtr
 {
     if (!checkRootElement())
         return nullptr;
-    EnumTypeEntryPtr entry(new EnumTypeEntry(name, since, currentParentTypeEntry()));
+    auto entry = std::make_shared<EnumTypeEntry>(name, since, currentParentTypeEntry());
     applyCommonAttributes(reader, entry, attributes);
     entry->setTargetLangPackage(m_defaultPackage);
 
@@ -1551,10 +1582,12 @@ EnumTypeEntryPtr
         } else if (name == u"lower-bound") {
             qCWarning(lcShiboken, "%s",
                       qPrintable(msgUnimplementedAttributeWarning(reader, name)));
-        } else if (name == forceIntegerAttribute()) {
+        } else if (name == docFileAttribute) {
+            entry->setDocFile(attributes->takeAt(i).value().toString());
+        } else if (name == forceIntegerAttribute) {
             qCWarning(lcShiboken, "%s",
                       qPrintable(msgUnimplementedAttributeWarning(reader, name)));
-        } else if (name == pythonEnumTypeAttribute()) {
+        } else if (name == pythonEnumTypeAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto typeOpt = pythonEnumTypeFromAttribute(attribute.value());
             if (typeOpt.has_value()) {
@@ -1563,12 +1596,12 @@ EnumTypeEntryPtr
                 qCWarning(lcShiboken, "%s",
                           qPrintable(msgInvalidAttributeValue(attribute)));
             }
-        } else if (name == cppEnumTypeAttribute()) {
+        } else if (name == cppEnumTypeAttribute) {
             entry->setCppType(attributes->takeAt(i).value().toString());
-        } else if (name == extensibleAttribute()) {
+        } else if (name == extensibleAttribute) {
             qCWarning(lcShiboken, "%s",
                       qPrintable(msgUnimplementedAttributeWarning(reader, name)));
-        } else if (name == flagsAttribute()) {
+        } else if (name == flagsAttribute) {
             flagNames = attributes->takeAt(i).value().toString();
         }
     }
@@ -1590,7 +1623,7 @@ NamespaceTypeEntryPtr
 {
     if (!checkRootElement())
         return nullptr;
-    NamespaceTypeEntryPtr result(new NamespaceTypeEntry(name, since, currentParentTypeEntry()));
+    auto result = std::make_shared<NamespaceTypeEntry>(name, since, currentParentTypeEntry());
     auto visibility = TypeSystem::Visibility::Unspecified;
     applyCommonAttributes(reader, result, attributes);
     for (auto i = attributes->size() - 1; i >= 0; --i) {
@@ -1616,7 +1649,7 @@ NamespaceTypeEntryPtr
             }
             result->setExtends(*extendsIt);
             attributes->removeAt(i);
-        } else if (attributeName == visibleAttribute()) {
+        } else if (attributeName == visibleAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto visibilityOpt = visibilityFromAttribute(attribute.value());
             if (!visibilityOpt.has_value()) {
@@ -1624,11 +1657,12 @@ NamespaceTypeEntryPtr
                 return nullptr;
             }
             visibility = visibilityOpt.value();
-        } else if (attributeName == generateAttribute()) {
-            if (!convertBoolean(attributes->takeAt(i).value(), generateAttribute(), true))
+        } else if (attributeName == generateAttribute) {
+            if (!convertBoolean(attributes->takeAt(i).value(), generateAttribute, true))
                 visibility = TypeSystem::Visibility::Invisible;
-        } else if (attributeName == generateUsingAttribute()) {
-            result->setGenerateUsing(convertBoolean(attributes->takeAt(i).value(), generateUsingAttribute(), true));
+        } else if (attributeName == generateUsingAttribute) {
+            result->setGenerateUsing(convertBoolean(attributes->takeAt(i).value(),
+                                                    generateUsingAttribute, true));
         }
     }
 
@@ -1652,7 +1686,7 @@ ValueTypeEntryPtr
 {
     if (!checkRootElement())
         return nullptr;
-    ValueTypeEntryPtr typeEntry(new ValueTypeEntry(name, since, currentParentTypeEntry()));
+    auto typeEntry = std::make_shared<ValueTypeEntry>(name, since, currentParentTypeEntry());
     if (!applyCommonAttributes(reader, typeEntry, attributes))
         return nullptr;
     applyComplexTypeAttributes(reader, typeEntry, attributes);
@@ -1671,45 +1705,51 @@ FunctionTypeEntryPtr
     if (!checkRootElement())
         return nullptr;
 
-    QString signature;
-    TypeSystem::SnakeCase snakeCase = TypeSystem::SnakeCase::Disabled;
+    FunctionModification mod;
+    const auto oldAttributesSize = attributes->size();
+    if (!parseModifyFunctionAttributes(attributes, &mod))
+        return nullptr;
+    const bool hasModification = attributes->size() < oldAttributesSize;
 
+    QString originalSignature;
+    QString docFile;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == signatureAttribute()) {
-            signature = TypeDatabase::normalizedSignature(attributes->takeAt(i).value().toString());
-        } else if (name == snakeCaseAttribute()) {
-            const auto attribute = attributes->takeAt(i);
-            const auto snakeCaseOpt = snakeCaseFromAttribute(attribute.value());
-            if (!snakeCaseOpt.has_value()) {
-                m_error = msgInvalidAttributeValue(attribute);
-                return nullptr;
-            }
-            snakeCase = snakeCaseOpt.value();
-        }
+        if (name == signatureAttribute)
+            originalSignature = attributes->takeAt(i).value().toString().simplified();
+        else if (name == docFileAttribute)
+            docFile = attributes->takeAt(i).value().toString();
     }
 
+    const QString signature = TypeDatabase::normalizedSignature(originalSignature);
     if (signature.isEmpty()) {
-        m_error =  msgMissingAttribute(signatureAttribute());
+        m_error =  msgMissingAttribute(signatureAttribute);
         return nullptr;
     }
 
+    if (hasModification) {
+        mod.setOriginalSignature(originalSignature);
+        mod.setSignature(signature);
+        m_contextStack.top()->functionMods << mod;
+    }
+
     TypeEntryPtr existingType = m_context->db->findType(name);
 
-    if (existingType.isNull()) {
-        FunctionTypeEntryPtr result(new FunctionTypeEntry(name, signature, since, currentParentTypeEntry()));
-        result->setSnakeCase(snakeCase);
+    if (!existingType) {
+        auto result = std::make_shared<FunctionTypeEntry>(name, signature, since,
+                                                          currentParentTypeEntry());
+        result->setTargetLangPackage(m_defaultPackage);
+        result->setDocFile(docFile);
         applyCommonAttributes(reader, result, attributes);
         return result;
     }
 
     if (existingType->type() != TypeEntry::FunctionType) {
-        m_error = QStringLiteral("%1 expected to be a function, but isn't! Maybe it was already declared as a class or something else.")
-                 .arg(name);
+        m_error = name + " expected to be a function, but isn't! Maybe it was already declared as a class or something else."_L1;
         return nullptr;
     }
 
-    auto result = qSharedPointerCast<FunctionTypeEntry>(existingType);
+    auto result = std::static_pointer_cast<FunctionTypeEntry>(existingType);
     result->addSignature(signature);
     return result;
 }
@@ -1727,13 +1767,14 @@ TypedefEntryPtr
         m_error = u"typedef entries must be nested in namespaces or type system."_s;
         return nullptr;
     }
-    const auto sourceIndex = indexOfAttribute(*attributes, sourceAttribute());
+    const auto sourceIndex = indexOfAttribute(*attributes, sourceAttribute);
     if (sourceIndex == -1) {
-        m_error =  msgMissingAttribute(sourceAttribute());
+        m_error =  msgMissingAttribute(sourceAttribute);
         return nullptr;
     }
     const QString sourceType = attributes->takeAt(sourceIndex).value().toString();
-    TypedefEntryPtr result(new TypedefEntry(name, sourceType, since, currentParentTypeEntry()));
+    auto result = std::make_shared<TypedefEntry>(name, sourceType, since,
+                                                 currentParentTypeEntry());
     if (!applyCommonAttributes(reader, result, attributes))
         return nullptr;
     applyComplexTypeAttributes(reader, result, attributes);
@@ -1752,34 +1793,38 @@ void TypeSystemParser::applyComplexTypeAttributes(const ConditionalStreamReader
     QString package = m_defaultPackage;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == streamAttribute()) {
-            ctype->setStream(convertBoolean(attributes->takeAt(i).value(), streamAttribute(), false));
-        } else if (name == privateAttribute()) {
+        if (name == streamAttribute) {
+            ctype->setStream(convertBoolean(attributes->takeAt(i).value(), streamAttribute, false));
+        } else if (name == privateAttribute) {
             ctype->setPrivate(convertBoolean(attributes->takeAt(i).value(),
-                                             privateAttribute(), false));
-        } else if (name == generateAttribute()) {
-            generate = convertBoolean(attributes->takeAt(i).value(), generateAttribute(), true);
-        } else if (name ==packageAttribute()) {
+                                             privateAttribute, false));
+        } else if (name == generateAttribute) {
+            generate = convertBoolean(attributes->takeAt(i).value(), generateAttribute, true);
+        } else if (name ==packageAttribute) {
             package = attributes->takeAt(i).value().toString();
-        } else if (name == defaultSuperclassAttribute()) {
+        } else if (name == defaultSuperclassAttribute) {
             ctype->setDefaultSuperclass(attributes->takeAt(i).value().toString());
-        } else if (name == genericClassAttribute()) {
+        } else if (name == genericClassAttribute) {
             qCWarning(lcShiboken, "%s",
                       qPrintable(msgUnimplementedAttributeWarning(reader, name)));
-            const bool v = convertBoolean(attributes->takeAt(i).value(), genericClassAttribute(), false);
+            const bool v = convertBoolean(attributes->takeAt(i).value(),
+                                          genericClassAttribute, false);
             ctype->setGenericClass(v);
-        } else if (name == targetLangNameAttribute()) {
+        } else if (name == targetLangNameAttribute) {
             ctype->setTargetLangName(attributes->takeAt(i).value().toString());
-        } else if (name == u"polymorphic-base") {
-            ctype->setPolymorphicIdValue(attributes->takeAt(i).value().toString());
+        } else if (name == polymorphicBaseAttribute) {
+            const bool v = convertBoolean(attributes->takeAt(i).value(),
+                                          polymorphicBaseAttribute, false);
+            ctype->setIsPolymorphicBase(v);
         } else if (name == u"polymorphic-name-function") {
             ctype->setPolymorphicNameFunction(attributes->takeAt(i).value().toString());
         } else if (name == u"polymorphic-id-expression") {
             ctype->setPolymorphicIdValue(attributes->takeAt(i).value().toString());
-        } else if (name == copyableAttribute()) {
-            const bool v = convertBoolean(attributes->takeAt(i).value(), copyableAttribute(), false);
+        } else if (name == copyableAttribute) {
+            const bool v = convertBoolean(attributes->takeAt(i).value(),
+                                          copyableAttribute, false);
             ctype->setCopyable(v ? ComplexTypeEntry::CopyableSet : ComplexTypeEntry::NonCopyableSet);
-        } else if (name == exceptionHandlingAttribute()) {
+        } else if (name == exceptionHandlingAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto exceptionOpt = exceptionHandlingFromAttribute(attribute.value());
             if (exceptionOpt.has_value()) {
@@ -1788,7 +1833,7 @@ void TypeSystemParser::applyComplexTypeAttributes(const ConditionalStreamReader
                 qCWarning(lcShiboken, "%s",
                           qPrintable(msgInvalidAttributeValue(attribute)));
             }
-        } else if (name == allowThreadAttribute()) {
+        } else if (name == allowThreadAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto allowThreadOpt = allowThreadFromAttribute(attribute.value());
             if (allowThreadOpt.has_value()) {
@@ -1802,19 +1847,25 @@ void TypeSystemParser::applyComplexTypeAttributes(const ConditionalStreamReader
                       qPrintable(msgUnimplementedAttributeWarning(reader, name)));
         } else if (name == u"hash-function") {
             ctype->setHashFunction(attributes->takeAt(i).value().toString());
-        } else if (name == forceAbstractAttribute()) {
-            if (convertBoolean(attributes->takeAt(i).value(), forceAbstractAttribute(), false))
+        } else if (name == forceAbstractAttribute) {
+            if (convertBoolean(attributes->takeAt(i).value(), forceAbstractAttribute, false))
                 ctype->setTypeFlags(ctype->typeFlags() | ComplexTypeEntry::ForceAbstract);
-        } else if (name == deprecatedAttribute()) {
-            if (convertBoolean(attributes->takeAt(i).value(), deprecatedAttribute(), false))
+        } else if (name == deprecatedAttribute) {
+            if (convertBoolean(attributes->takeAt(i).value(), deprecatedAttribute, false))
                 ctype->setTypeFlags(ctype->typeFlags() | ComplexTypeEntry::Deprecated);
-        } else if (name == disableWrapperAttribute()) {
-            if (convertBoolean(attributes->takeAt(i).value(), disableWrapperAttribute(), false))
+        } else if (name == disableWrapperAttribute) {
+            if (convertBoolean(attributes->takeAt(i).value(), disableWrapperAttribute, false))
                 ctype->setTypeFlags(ctype->typeFlags() | ComplexTypeEntry::DisableWrapper);
-        } else if (name == deleteInMainThreadAttribute()) {
-            if (convertBoolean(attributes->takeAt(i).value(), deleteInMainThreadAttribute(), false))
+        } else if (name == deleteInMainThreadAttribute) {
+            if (convertBoolean(attributes->takeAt(i).value(), deleteInMainThreadAttribute, false))
                 ctype->setDeleteInMainThread(true);
-        } else if (name == generateFunctionsAttribute()) {
+        } else if (name == qtMetaObjectFunctionsAttribute) {
+            if (!convertBoolean(attributes->takeAt(i).value(),
+                                qtMetaObjectFunctionsAttribute, true))  {
+                ctype->setTypeFlags(ctype->typeFlags()
+                                    | ComplexTypeEntry::DisableQtMetaObjectFunctions);
+            }
+        } else if (name == generateFunctionsAttribute) {
             const auto names = attributes->takeAt(i).value();
             const auto nameList = names.split(u';', Qt::SkipEmptyParts);
             QSet<QString> nameSet;
@@ -1823,7 +1874,7 @@ void TypeSystemParser::applyComplexTypeAttributes(const ConditionalStreamReader
             ctype->setGenerateFunctions(nameSet);
         } else if (name == u"target-type") {
             ctype->setTargetType(attributes->takeAt(i).value().toString());
-        }  else if (name == snakeCaseAttribute()) {
+        }  else if (name == snakeCaseAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto snakeCaseOpt = snakeCaseFromAttribute(attribute.value());
             if (snakeCaseOpt.has_value()) {
@@ -1832,7 +1883,7 @@ void TypeSystemParser::applyComplexTypeAttributes(const ConditionalStreamReader
                 qCWarning(lcShiboken, "%s",
                           qPrintable(msgInvalidAttributeValue(attribute)));
             }
-        }  else if (name == isNullAttribute()) {
+        }  else if (name == isNullAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto boolCastOpt = boolCastFromAttribute(attribute.value());
             if (boolCastOpt.has_value()) {
@@ -1841,7 +1892,7 @@ void TypeSystemParser::applyComplexTypeAttributes(const ConditionalStreamReader
                 qCWarning(lcShiboken, "%s",
                           qPrintable(msgInvalidAttributeValue(attribute)));
             }
-        }  else if (name == operatorBoolAttribute()) {
+        }  else if (name == operatorBoolAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto boolCastOpt = boolCastFromAttribute(attribute.value());
             if (boolCastOpt.has_value()) {
@@ -1850,7 +1901,7 @@ void TypeSystemParser::applyComplexTypeAttributes(const ConditionalStreamReader
                 qCWarning(lcShiboken, "%s",
                           qPrintable(msgInvalidAttributeValue(attribute)));
             }
-        } else if (name == qtMetaTypeAttribute()) {
+        } else if (name == qtMetaTypeAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto qtMetaTypeOpt = qtMetaTypeFromAttribute(attribute.value());
             if (qtMetaTypeOpt.has_value()) {
@@ -1859,9 +1910,9 @@ void TypeSystemParser::applyComplexTypeAttributes(const ConditionalStreamReader
                 qCWarning(lcShiboken, "%s",
                           qPrintable(msgInvalidAttributeValue(attribute)));
             }
-        } else if (name == parentManagementAttribute()) {
+        } else if (name == parentManagementAttribute) {
             const auto attribute = attributes->takeAt(i);
-            if (convertBoolean(attribute.value(), parentManagementAttribute(), false))
+            if (convertBoolean(attribute.value(), parentManagementAttribute, false))
                 ctype->setTypeFlags(ctype->typeFlags() | ComplexTypeEntry::ParentManagement);
             ComplexTypeEntry::setParentManagementEnabled(true);
         }
@@ -1882,6 +1933,32 @@ void TypeSystemParser::applyComplexTypeAttributes(const ConditionalStreamReader
         ctype->setCodeGeneration(TypeEntry::GenerationDisabled);
 }
 
+bool TypeSystemParser::parseConfiguration(StackElement topElement,
+                                          QXmlStreamAttributes *attributes)
+{
+    if (!isComplexTypeEntry(topElement)
+        && topElement != StackElement::EnumTypeEntry) {
+        m_error = u"<configuration> must be nested into a complex or enum type entry."_s;
+        return false;
+    }
+    QString condition;
+    for (auto i = attributes->size() - 1; i >= 0; --i) {
+        const auto name = attributes->at(i).qualifiedName();
+        if (name == u"condition") {
+            condition = attributes->takeAt(i).value().toString();
+        }
+    }
+    if (condition.isEmpty()) {
+        m_error = u"<configuration> requires a \"condition\" attribute."_s;
+        return false;
+    }
+    const auto topEntry = m_contextStack.top()->entry;
+    const auto configurableEntry = std::dynamic_pointer_cast<ConfigurableTypeEntry>(topEntry);
+    Q_ASSERT(configurableEntry);
+    configurableEntry->setConfigCondition(condition);
+    return true;
+}
+
 bool TypeSystemParser::parseRenameFunction(const ConditionalStreamReader &,
                                   QString *name, QXmlStreamAttributes *attributes)
 {
@@ -1889,16 +1966,16 @@ bool TypeSystemParser::parseRenameFunction(const ConditionalStreamReader &,
     QString rename;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == signatureAttribute()) {
+        if (name == signatureAttribute) {
             // Do not remove as it is needed for the type entry later on
-            signature = attributes->at(i).value().toString();
-        } else if (name == renameAttribute()) {
+            signature = attributes->at(i).value().toString().simplified();
+        } else if (name == renameAttribute) {
             rename = attributes->takeAt(i).value().toString();
         }
     }
 
     if (signature.isEmpty()) {
-        m_error = msgMissingAttribute(signatureAttribute());
+        m_error = msgMissingAttribute(signatureAttribute);
         return false;
     }
 
@@ -1954,7 +2031,7 @@ bool TypeSystemParser::parseInjectDocumentation(const ConditionalStreamReader &,
                 return false;
             }
             mode = modeOpt.value();
-        } else if (name == formatAttribute()) {
+        } else if (name == formatAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto langOpt = languageFromAttribute(attribute.value());
             if (!langOpt.has_value()) {
@@ -1968,6 +2045,12 @@ bool TypeSystemParser::parseInjectDocumentation(const ConditionalStreamReader &,
     QString signature = isTypeEntry(topElement) ? QString() : m_currentSignature;
     DocModification mod(mode, signature);
     mod.setFormat(lang);
+    if (hasFileSnippetAttributes(attributes)) {
+        const auto snippetOptional = readFileSnippet(attributes);
+        if (!snippetOptional.has_value())
+            return false;
+        mod.setCode(snippetOptional.value().content);
+    }
     auto &top = m_contextStack.top();
     if (isAddFunction)
         top->addedFunctions.last()->addDocModification(mod);
@@ -1989,9 +2072,9 @@ bool TypeSystemParser::parseModifyDocumentation(const ConditionalStreamReader &,
         return false;
     }
 
-    const auto xpathIndex = indexOfAttribute(*attributes, xPathAttribute());
+    const auto xpathIndex = indexOfAttribute(*attributes, xPathAttribute);
     if (xpathIndex == -1) {
-        m_error = msgMissingAttribute(xPathAttribute());
+        m_error = msgMissingAttribute(xPathAttribute);
         return false;
     }
 
@@ -2008,14 +2091,17 @@ TypeSystemTypeEntryPtr TypeSystemParser::parseRootElement(const ConditionalStrea
                                                QXmlStreamAttributes *attributes)
 {
     TypeSystem::SnakeCase snakeCase = TypeSystem::SnakeCase::Unspecified;
+    QString subModuleOf;
+    QString namespaceBegin;
+    QString namespaceEnd;
 
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == packageAttribute()) {
+        if (name == packageAttribute) {
             m_defaultPackage = attributes->takeAt(i).value().toString();
-        } else if (name == defaultSuperclassAttribute()) {
+        } else if (name == defaultSuperclassAttribute) {
             m_defaultSuperclass = attributes->takeAt(i).value().toString();
-        } else if (name == exceptionHandlingAttribute()) {
+        } else if (name == exceptionHandlingAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto exceptionOpt = exceptionHandlingFromAttribute(attribute.value());
             if (exceptionOpt.has_value()) {
@@ -2024,7 +2110,7 @@ TypeSystemTypeEntryPtr TypeSystemParser::parseRootElement(const ConditionalStrea
                 qCWarning(lcShiboken, "%s",
                           qPrintable(msgInvalidAttributeValue(attribute)));
             }
-        } else if (name == allowThreadAttribute()) {
+        } else if (name == allowThreadAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto allowThreadOpt = allowThreadFromAttribute(attribute.value());
             if (allowThreadOpt.has_value()) {
@@ -2033,7 +2119,7 @@ TypeSystemTypeEntryPtr TypeSystemParser::parseRootElement(const ConditionalStrea
                 qCWarning(lcShiboken, "%s",
                           qPrintable(msgInvalidAttributeValue(attribute)));
             }
-        } else if (name == snakeCaseAttribute()) {
+        } else if (name == snakeCaseAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto snakeCaseOpt = snakeCaseFromAttribute(attribute.value());
             if (snakeCaseOpt.has_value()) {
@@ -2042,25 +2128,36 @@ TypeSystemTypeEntryPtr TypeSystemParser::parseRootElement(const ConditionalStrea
                 qCWarning(lcShiboken, "%s",
                           qPrintable(msgInvalidAttributeValue(attribute)));
             }
+        } else if (name == subModuleOfAttribute) {
+            subModuleOf = attributes->takeAt(i).value().toString();
+        } else if (name == "namespace-begin"_L1) {
+            namespaceBegin = attributes->takeAt(i).value().toString();
+        } else if (name == "namespace-end"_L1) {
+            namespaceEnd = attributes->takeAt(i).value().toString();
         }
     }
 
     if (m_defaultPackage.isEmpty()) { // Extending default, see addBuiltInContainerTypes()
-        auto moduleEntry = qSharedPointerConstCast<TypeSystemTypeEntry>(m_context->db->defaultTypeSystemType());
-        Q_ASSERT(!moduleEntry.isNull());
+        auto moduleEntry = std::const_pointer_cast<TypeSystemTypeEntry>(m_context->db->defaultTypeSystemType());
+        Q_ASSERT(moduleEntry);
         m_defaultPackage = moduleEntry->name();
         return moduleEntry;
     }
 
     auto moduleEntry =
-        qSharedPointerConstCast<TypeSystemTypeEntry>(m_context->db->findTypeSystemType(m_defaultPackage));
-    const bool add = moduleEntry.isNull();
+        std::const_pointer_cast<TypeSystemTypeEntry>(m_context->db->findTypeSystemType(m_defaultPackage));
+    const bool add = !moduleEntry;
     if (add) {
         moduleEntry.reset(new TypeSystemTypeEntry(m_defaultPackage, since,
                                                   currentParentTypeEntry()));
+        moduleEntry->setSubModule(subModuleOf);
     }
     moduleEntry->setCodeGeneration(m_generate);
     moduleEntry->setSnakeCase(snakeCase);
+    if (!namespaceBegin.isEmpty())
+        moduleEntry->setNamespaceBegin(namespaceBegin);
+    if (!namespaceEnd.isEmpty())
+        moduleEntry->setNamespaceEnd(namespaceEnd);
 
     if ((m_generate == TypeEntry::GenerateForSubclass ||
          m_generate == TypeEntry::GenerateNothing) && !m_defaultPackage.isEmpty())
@@ -2078,10 +2175,10 @@ bool TypeSystemParser::loadTypesystem(const ConditionalStreamReader &,
     bool generateChild = true;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == nameAttribute())
+        if (name == nameAttribute)
             typeSystemName = attributes->takeAt(i).value().toString();
-        else if (name == generateAttribute())
-           generateChild = convertBoolean(attributes->takeAt(i).value(), generateAttribute(), true);
+        else if (name == generateAttribute)
+           generateChild = convertBoolean(attributes->takeAt(i).value(), generateAttribute, true);
     }
     if (typeSystemName.isEmpty()) {
             m_error = u"No typesystem name specified"_s;
@@ -2098,13 +2195,13 @@ bool TypeSystemParser::loadTypesystem(const ConditionalStreamReader &,
 bool TypeSystemParser::parseRejectEnumValue(const ConditionalStreamReader &,
                                    QXmlStreamAttributes *attributes)
 {
-    if (m_currentEnum.isNull()) {
+    if (!m_currentEnum) {
         m_error = u"<reject-enum-value> node must be used inside a <enum-type> node"_s;
         return false;
     }
-    const auto nameIndex = indexOfAttribute(*attributes, nameAttribute());
+    const auto nameIndex = indexOfAttribute(*attributes, nameAttribute);
     if (nameIndex == -1) {
-        m_error = msgMissingAttribute(nameAttribute());
+        m_error = msgMissingAttribute(nameAttribute);
         return false;
     }
     m_currentEnum->addEnumValueRejection(attributes->takeAt(nameIndex).value().toString());
@@ -2119,7 +2216,7 @@ bool TypeSystemParser::parseReplaceArgumentType(const ConditionalStreamReader &,
         m_error = u"Type replacement can only be specified for argument modifications"_s;
         return false;
     }
-    const auto modifiedTypeIndex = indexOfAttribute(*attributes, modifiedTypeAttribute());
+    const auto modifiedTypeIndex = indexOfAttribute(*attributes, modifiedTypeAttribute);
     if (modifiedTypeIndex == -1) {
         m_error = u"Type replacement requires 'modified-type' attribute"_s;
         return false;
@@ -2147,7 +2244,7 @@ bool TypeSystemParser::parseCustomConversion(const ConditionalStreamReader &,
     TypeSystem::Language lang = TypeSystem::NativeCode;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == classAttribute()) {
+        if (name == classAttribute) {
             const auto languageAttribute = attributes->takeAt(i);
             const auto langOpt = languageFromAttribute(languageAttribute.value());
             if (!langOpt.has_value()) {
@@ -2157,7 +2254,7 @@ bool TypeSystemParser::parseCustomConversion(const ConditionalStreamReader &,
             lang = langOpt.value();
         } else if (name == u"file") {
             sourceFile = attributes->takeAt(i).value().toString();
-        } else if (name == snippetAttribute()) {
+        } else if (name == snippetAttribute) {
             snippetLabel = attributes->takeAt(i).value().toString();
         }
     }
@@ -2172,7 +2269,7 @@ bool TypeSystemParser::parseCustomConversion(const ConditionalStreamReader &,
 
     ValueTypeEntryPtr valueTypeEntry;
     if (top->entry->isValue()) {
-        valueTypeEntry = qSharedPointerCast<ValueTypeEntry>(top->entry);
+        valueTypeEntry = std::static_pointer_cast<ValueTypeEntry>(top->entry);
         if (valueTypeEntry->hasTargetConversionRule() || valueTypeEntry->hasCustomConversion()) {
             m_error = u"Types can have only one conversion rule"_s;
             return false;
@@ -2204,13 +2301,13 @@ bool TypeSystemParser::parseCustomConversion(const ConditionalStreamReader &,
         return true;
     }
 
-    CustomConversionPtr customConversion(new CustomConversion(top->entry));
+    auto customConversion = std::make_shared<CustomConversion>(top->entry);
     if (top->entry->isPrimitive())
-        qSharedPointerCast<PrimitiveTypeEntry>(top->entry)->setCustomConversion(customConversion);
+        std::static_pointer_cast<PrimitiveTypeEntry>(top->entry)->setCustomConversion(customConversion);
     else if (top->entry->isContainer())
-        qSharedPointerCast<ContainerTypeEntry>(top->entry)->setCustomConversion(customConversion);
+        std::static_pointer_cast<ContainerTypeEntry>(top->entry)->setCustomConversion(customConversion);
     else if (top->entry->isValue())
-        qSharedPointerCast<ValueTypeEntry>(top->entry)->setCustomConversion(customConversion);
+        std::static_pointer_cast<ValueTypeEntry>(top->entry)->setCustomConversion(customConversion);
     customConversionsForReview.append(customConversion);
     return true;
 }
@@ -2224,7 +2321,7 @@ bool TypeSystemParser::parseNativeToTarget(const ConditionalStreamReader &,
         return false;
     }
     CodeSnip snip;
-    if (!readFileSnippet(attributes, &snip))
+    if (!readCodeSnippet(attributes, &snip))
         return false;
     m_contextStack.top()->conversionCodeSnips.append(snip);
     return true;
@@ -2241,7 +2338,7 @@ bool TypeSystemParser::parseAddConversion(const ConditionalStreamReader &,
     QString sourceTypeName;
     QString typeCheck;
     CodeSnip snip;
-    if (!readFileSnippet(attributes, &snip))
+    if (!readCodeSnippet(attributes, &snip))
         return false;
 
     const auto &top = m_contextStack.top();
@@ -2263,7 +2360,7 @@ bool TypeSystemParser::parseAddConversion(const ConditionalStreamReader &,
         return false;
     }
     auto customConversion = CustomConversion::getCustomConversion(top->entry);
-    if (customConversion.isNull()) {
+    if (!customConversion) {
         m_error = msgMissingCustomConversion(top->entry);
         return false;
     }
@@ -2276,7 +2373,7 @@ static bool parseIndex(const QString &index, int *result, QString *errorMessage)
     bool ok = false;
     *result = index.toInt(&ok);
     if (!ok)
-        *errorMessage = QStringLiteral("Cannot convert '%1' to integer").arg(index);
+        *errorMessage = QString::fromLatin1("Cannot convert '%1' to integer").arg(index);
     return ok;
 }
 
@@ -2311,20 +2408,20 @@ bool TypeSystemParser::parseModifyArgument(const ConditionalStreamReader &,
     bool resetAfterUse = false;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == indexAttribute()) {
+        if (name == indexAttribute) {
              index = attributes->takeAt(i).value().toString();
-        } else if (name == invalidateAfterUseAttribute()) {
+        } else if (name == invalidateAfterUseAttribute) {
             resetAfterUse = convertBoolean(attributes->takeAt(i).value(),
-                                           invalidateAfterUseAttribute(), false);
-        } else if (name == renameAttribute()) {
+                                           invalidateAfterUseAttribute, false);
+        } else if (name == renameAttribute) {
             renameTo = attributes->takeAt(i).value().toString();
-        } else if (name == pyiTypeAttribute()) {
+        } else if (name == pyiTypeAttribute) {
             pyiType = attributes->takeAt(i).value().toString();
         }
     }
 
     if (index.isEmpty()) {
-        m_error = msgMissingAttribute(indexAttribute());
+        m_error = msgMissingAttribute(indexAttribute);
         return false;
     }
 
@@ -2374,7 +2471,7 @@ bool TypeSystemParser::parseDefineOwnership(const ConditionalStreamReader &,
     std::optional<TypeSystem::Ownership> ownershipOpt;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == classAttribute()) {
+        if (name == classAttribute) {
             const auto classAttribute = attributes->takeAt(i);
             const auto langOpt = languageFromAttribute(classAttribute.value());
             if (!langOpt.has_value() || langOpt.value() == TypeSystem::ShellCode) {
@@ -2382,7 +2479,7 @@ bool TypeSystemParser::parseDefineOwnership(const ConditionalStreamReader &,
                 return false;
             }
             lang = langOpt.value();
-        } else if (name == ownershipAttribute()) {
+        } else if (name == ownershipAttribute) {
             const auto attribute = attributes->takeAt(i);
             ownershipOpt = ownershipFromFromAttribute(attribute.value());
             if (!ownershipOpt.has_value()) {
@@ -2393,7 +2490,7 @@ bool TypeSystemParser::parseDefineOwnership(const ConditionalStreamReader &,
     }
 
     if (!ownershipOpt.has_value()) {
-        m_error = QStringLiteral("unspecified ownership");
+        m_error = "unspecified ownership"_L1;
         return false;
     }
     auto &lastArgMod = m_contextStack.top()->functionMods.last().argument_mods().last();
@@ -2420,9 +2517,9 @@ bool TypeSystemParser::parseRename(const ConditionalStreamReader &,
         return false;
     }
 
-    const auto toIndex = indexOfAttribute(*attributes, toAttribute());
+    const auto toIndex = indexOfAttribute(*attributes, toAttribute);
     if (toIndex == -1) {
-        m_error = msgMissingAttribute(toAttribute());
+        m_error = msgMissingAttribute(toAttribute);
         return false;
     }
     const QString renamed_to = attributes->takeAt(toIndex).value().toString();
@@ -2436,20 +2533,20 @@ bool TypeSystemParser::parseModifyField(const ConditionalStreamReader &,
     FieldModification fm;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == nameAttribute()) {
+        if (name == nameAttribute) {
             fm.setName(attributes->takeAt(i).value().toString());
-        } else if (name == removeAttribute()) {
+        } else if (name == removeAttribute) {
             fm.setRemoved(convertRemovalAttribute(attributes->takeAt(i).value()));
-        } else if (name == opaqueContainerFieldAttribute()) {
+        } else if (name == opaqueContainerFieldAttribute) {
             fm.setOpaqueContainer(convertBoolean(attributes->takeAt(i).value(),
-                                                 opaqueContainerFieldAttribute(), false));
-        }  else if (name == readAttribute()) {
-            fm.setReadable(convertBoolean(attributes->takeAt(i).value(), readAttribute(), true));
-        } else if (name == writeAttribute()) {
-            fm.setWritable(convertBoolean(attributes->takeAt(i).value(), writeAttribute(), true));
-        } else if (name == renameAttribute()) {
+                                                 opaqueContainerFieldAttribute, false));
+        }  else if (name == readAttribute) {
+            fm.setReadable(convertBoolean(attributes->takeAt(i).value(), readAttribute, true));
+        } else if (name == writeAttribute) {
+            fm.setWritable(convertBoolean(attributes->takeAt(i).value(), writeAttribute, true));
+        } else if (name == renameAttribute) {
             fm.setRenamedToName(attributes->takeAt(i).value().toString());
-        } else if (name == snakeCaseAttribute()) {
+        } else if (name == snakeCaseAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto snakeCaseOpt = snakeCaseFromAttribute(attribute.value());
             if (snakeCaseOpt.has_value()) {
@@ -2461,7 +2558,7 @@ bool TypeSystemParser::parseModifyField(const ConditionalStreamReader &,
         }
     }
     if (fm.name().isEmpty()) {
-        m_error = msgMissingAttribute(nameAttribute());
+        m_error = msgMissingAttribute(nameAttribute);
         return false;
     }
     m_contextStack.top()->fieldMods << fm;
@@ -2493,29 +2590,37 @@ bool TypeSystemParser::parseAddFunction(const ConditionalStreamReader &,
                                       ", was=%1").arg(tagFromElement(topElement));
         return false;
     }
+
+    FunctionModification mod;
+    if (!(t == StackElement::AddFunction
+          ? parseBasicModifyFunctionAttributes(attributes, &mod)
+          : parseModifyFunctionAttributes(attributes, &mod))) {
+        return false;
+    }
+
     QString originalSignature;
     QString returnType;
     bool staticFunction = false;
     bool classMethod = false;
+    bool pythonOverride = false;
     QString access;
-    int overloadNumber = TypeSystem::OverloadNumberUnset;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == u"signature") {
-            originalSignature = attributes->takeAt(i).value().toString();
+        if (name == signatureAttribute) {
+            originalSignature = attributes->takeAt(i).value().toString().simplified();
         } else if (name == u"return-type") {
             returnType = attributes->takeAt(i).value().toString();
-        } else if (name == staticAttribute()) {
+        } else if (name == staticAttribute) {
             staticFunction = convertBoolean(attributes->takeAt(i).value(),
-                                            staticAttribute(), false);
-        } else if (name == classmethodAttribute()) {
+                                            staticAttribute, false);
+        } else if (name == classmethodAttribute) {
             classMethod = convertBoolean(attributes->takeAt(i).value(),
-                                            classmethodAttribute(), false);
-        } else if (name == accessAttribute()) {
+                                            classmethodAttribute, false);
+        } else if (name == accessAttribute) {
             access = attributes->takeAt(i).value().toString();
-        } else if (name == overloadNumberAttribute()) {
-            if (!parseOverloadNumber(attributes->takeAt(i), &overloadNumber, &m_error))
-                return false;
+        } else if (name == pythonOverrideAttribute) {
+            pythonOverride = convertBoolean(attributes->takeAt(i).value(),
+                                            pythonOverrideAttribute, false);
         }
     }
 
@@ -2532,13 +2637,15 @@ bool TypeSystemParser::parseAddFunction(const ConditionalStreamReader &,
     }
 
     AddedFunctionPtr func = AddedFunction::createAddedFunction(signature, returnType, &errorString);
-    if (func.isNull()) {
+    if (!func) {
         m_error = errorString;
         return false;
     }
 
     func->setStatic(staticFunction);
     func->setClassMethod(classMethod);
+    func->setPythonOverride(pythonOverride);
+    func->setTargetLangPackage(m_defaultPackage);
 
     // Create signature for matching modifications
     signature = TypeDatabase::normalizedSignature(originalSignature);
@@ -2560,8 +2667,6 @@ bool TypeSystemParser::parseAddFunction(const ConditionalStreamReader &,
     m_contextStack.top()->addedFunctionModificationIndex =
         m_contextStack.top()->functionMods.size();
 
-    FunctionModification mod;
-    mod.setOverloadNumber(overloadNumber);
     if (!mod.setSignature(m_currentSignature, &m_error))
         return false;
     mod.setOriginalSignature(originalSignature);
@@ -2582,7 +2687,7 @@ bool TypeSystemParser::parseAddPyMethodDef(const ConditionalStreamReader &,
     TypeSystemPyMethodDefEntry def;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == nameAttribute()) {
+        if (name == nameAttribute) {
             def.name = attributes->takeAt(i).value().toString();
         } else if (name == u"doc") {
             def.doc = attributes->takeAt(i).value().toString();
@@ -2605,7 +2710,7 @@ bool TypeSystemParser::parseAddPyMethodDef(const ConditionalStreamReader &,
         m_error = u"add-pymethoddef requires at least a name and a function attribute"_s;
         return false;
     }
-    qSharedPointerCast<ComplexTypeEntry>(m_contextStack.top()->entry)->addPyMethodDef(def);
+    std::static_pointer_cast<ComplexTypeEntry>(m_contextStack.top()->entry)->addPyMethodDef(def);
     return true;
 }
 
@@ -2621,7 +2726,7 @@ bool TypeSystemParser::parseProperty(const ConditionalStreamReader &, StackEleme
     TypeSystemProperty property;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == nameAttribute()) {
+        if (name == nameAttribute) {
             property.name = attributes->takeAt(i).value().toString();
         } else if (name == u"get") {
             property.read = attributes->takeAt(i).value().toString();
@@ -2629,17 +2734,78 @@ bool TypeSystemParser::parseProperty(const ConditionalStreamReader &, StackEleme
             property.type = attributes->takeAt(i).value().toString();
         } else if (name == u"set") {
             property.write = attributes->takeAt(i).value().toString();
-        } else if (name == generateGetSetDefAttribute()) {
+        } else if (name == generateGetSetDefAttribute) {
             property.generateGetSetDef =
                 convertBoolean(attributes->takeAt(i).value(),
-                               generateGetSetDefAttribute(), false);
+                               generateGetSetDefAttribute, false);
         }
     }
     if (!property.isValid()) {
         m_error = u"<property> element is missing required attibutes (name/type/get)."_s;
         return false;
     }
-    qSharedPointerCast<ComplexTypeEntry>(m_contextStack.top()->entry)->addProperty(property);
+    std::static_pointer_cast<ComplexTypeEntry>(m_contextStack.top()->entry)->addProperty(property);
+    return true;
+}
+
+// Parse basic attributes applicable to <add-function>/<declare-function>/<function>
+// and <modify-function> (all that is not done by injected code).
+bool TypeSystemParser::parseBasicModifyFunctionAttributes(QXmlStreamAttributes *attributes,
+                                                          FunctionModification *mod)
+{
+    for (auto i = attributes->size() - 1; i >= 0; --i) {
+        const auto name = attributes->at(i).qualifiedName();
+        if (name == overloadNumberAttribute) {
+            int overloadNumber = TypeSystem::OverloadNumberUnset;
+            if (!parseOverloadNumber(attributes->takeAt(i), &overloadNumber, &m_error))
+                return false;
+            mod->setOverloadNumber(overloadNumber);
+        }
+    }
+    return true;
+}
+
+// Parse attributes applicable to <declare-function>/<function>
+// and <modify-function>.
+bool TypeSystemParser::parseModifyFunctionAttributes(QXmlStreamAttributes *attributes,
+                                                     FunctionModification *mod)
+{
+    if (!parseBasicModifyFunctionAttributes(attributes, mod))
+        return false;
+
+    for (auto i = attributes->size() - 1; i >= 0; --i) {
+        const auto name = attributes->at(i).qualifiedName();
+        if (name == allowThreadAttribute) {
+            const QXmlStreamAttribute attribute = attributes->takeAt(i);
+            const auto allowThreadOpt = allowThreadFromAttribute(attribute.value());
+            if (!allowThreadOpt.has_value()) {
+                m_error = msgInvalidAttributeValue(attribute);
+                return false;
+            }
+            mod->setAllowThread(allowThreadOpt.value());
+        } else if (name == exceptionHandlingAttribute) {
+            const auto attribute = attributes->takeAt(i);
+            const auto exceptionOpt = exceptionHandlingFromAttribute(attribute.value());
+            if (!exceptionOpt.has_value()) {
+                m_error = msgInvalidAttributeValue(attribute);
+                return false;
+            }
+            mod->setExceptionHandling(exceptionOpt.value());
+        } else if (name == snakeCaseAttribute) {
+            const auto attribute = attributes->takeAt(i);
+            const auto snakeCaseOpt = snakeCaseFromAttribute(attribute.value());
+            if (!snakeCaseOpt.has_value()) {
+                m_error = msgInvalidAttributeValue(attribute);
+                return false;
+            }
+            mod->setSnakeCase(snakeCaseOpt.value());
+        } else if (name == deprecatedAttribute) {
+            const bool deprecated = convertBoolean(attributes->takeAt(i).value(),
+                                                   deprecatedAttribute, false);
+            mod->setModifierFlag(deprecated ? FunctionModification::Deprecated
+                                            : FunctionModification::Undeprecated);
+        }
+    }
     return true;
 }
 
@@ -2657,61 +2823,24 @@ bool TypeSystemParser::parseModifyFunction(const ConditionalStreamReader &reader
     }
 
     QString originalSignature;
+    FunctionModification mod;
+    if (!parseModifyFunctionAttributes(attributes, &mod))
+        return false;
+
     QString access;
     bool removed = false;
     QString rename;
-    bool deprecated = false;
-    bool isThread = false;
-    int overloadNumber = TypeSystem::OverloadNumberUnset;
-    TypeSystem::ExceptionHandling exceptionHandling = TypeSystem::ExceptionHandling::Unspecified;
-    TypeSystem::AllowThread allowThread = TypeSystem::AllowThread::Unspecified;
-    TypeSystem::SnakeCase snakeCase = TypeSystem::SnakeCase::Unspecified;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == u"signature") {
-            originalSignature = attributes->takeAt(i).value().toString();
-        } else if (name == accessAttribute()) {
+        if (name == signatureAttribute) {
+            originalSignature = attributes->takeAt(i).value().toString().simplified();
+        } else if (name == accessAttribute) {
             access = attributes->takeAt(i).value().toString();
-        } else if (name == renameAttribute()) {
+        } else if (name == renameAttribute) {
             rename = attributes->takeAt(i).value().toString();
-        } else if (name == removeAttribute()) {
+        } else if (name == removeAttribute) {
             removed = convertRemovalAttribute(attributes->takeAt(i).value());
-        } else if (name == deprecatedAttribute()) {
-            deprecated = convertBoolean(attributes->takeAt(i).value(),
-                                        deprecatedAttribute(), false);
-        } else if (name == threadAttribute()) {
-            isThread = convertBoolean(attributes->takeAt(i).value(),
-                                      threadAttribute(), false);
-        } else if (name == allowThreadAttribute()) {
-            const QXmlStreamAttribute attribute = attributes->takeAt(i);
-            const auto allowThreadOpt = allowThreadFromAttribute(attribute.value());
-            if (!allowThreadOpt.has_value()) {
-                m_error = msgInvalidAttributeValue(attribute);
-                return false;
-            }
-            allowThread = allowThreadOpt.value();
-        } else if (name == exceptionHandlingAttribute()) {
-            const auto attribute = attributes->takeAt(i);
-            const auto exceptionOpt = exceptionHandlingFromAttribute(attribute.value());
-            if (exceptionOpt.has_value()) {
-                exceptionHandling = exceptionOpt.value();
-            } else {
-                qCWarning(lcShiboken, "%s",
-                          qPrintable(msgInvalidAttributeValue(attribute)));
-            }
-        } else if (name == overloadNumberAttribute()) {
-            if (!parseOverloadNumber(attributes->takeAt(i), &overloadNumber, &m_error))
-                return false;
-        } else if (name == snakeCaseAttribute()) {
-            const auto attribute = attributes->takeAt(i);
-            const auto snakeCaseOpt = snakeCaseFromAttribute(attribute.value());
-            if (snakeCaseOpt.has_value()) {
-                snakeCase = snakeCaseOpt.value();
-            } else {
-                qCWarning(lcShiboken, "%s",
-                          qPrintable(msgInvalidAttributeValue(attribute)));
-            }
-        } else if (name == virtualSlotAttribute()) {
+        } else if (name == virtualSlotAttribute || name == threadAttribute) {
             qCWarning(lcShiboken, "%s",
                       qPrintable(msgUnimplementedAttributeWarning(reader, name)));
         }
@@ -2720,7 +2849,7 @@ bool TypeSystemParser::parseModifyFunction(const ConditionalStreamReader &reader
     // Child of global <function>
     const auto &top = m_contextStack.top();
     if (originalSignature.isEmpty() && top->entry->isFunction()) {
-        auto f = qSharedPointerCast<const FunctionTypeEntry>(top->entry);
+        auto f = std::static_pointer_cast<const FunctionTypeEntry>(top->entry);
         originalSignature = f->signatures().value(0);
     }
 
@@ -2736,13 +2865,9 @@ bool TypeSystemParser::parseModifyFunction(const ConditionalStreamReader &reader
         return false;
     }
 
-    FunctionModification mod;
     if (!mod.setSignature(signature, &m_error))
         return false;
     mod.setOriginalSignature(originalSignature);
-    mod.setExceptionHandling(exceptionHandling);
-    mod.setOverloadNumber(overloadNumber);
-    mod.setSnakeCase(snakeCase);
     m_currentSignature = signature;
 
     if (!access.isEmpty()) {
@@ -2755,14 +2880,11 @@ bool TypeSystemParser::parseModifyFunction(const ConditionalStreamReader &reader
         if (m == FunctionModification::NonFinal) {
             qCWarning(lcShiboken, "%s",
                       qPrintable(msgUnimplementedAttributeValueWarning(reader,
-                      accessAttribute(), access)));
+                      accessAttribute, access)));
         }
         mod.setModifierFlag(m);
     }
 
-    if (deprecated)
-        mod.setModifierFlag(FunctionModification::Deprecated);
-
     mod.setRemoved(removed);
 
     if (!rename.isEmpty()) {
@@ -2770,10 +2892,6 @@ bool TypeSystemParser::parseModifyFunction(const ConditionalStreamReader &reader
         mod.setModifierFlag(FunctionModification::Rename);
     }
 
-    mod.setIsThread(isThread);
-    if (allowThread != TypeSystem::AllowThread::Unspecified)
-        mod.setAllowThread(allowThread);
-
     top->functionMods << mod;
     return true;
 }
@@ -2809,7 +2927,7 @@ bool TypeSystemParser::parseReferenceCount(const ConditionalStreamReader &reader
     ReferenceCount rc;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == actionAttribute()) {
+        if (name == actionAttribute) {
             const QXmlStreamAttribute attribute = attributes->takeAt(i);
             const auto actionOpt = referenceCountFromAttribute(attribute.value());
             if (!actionOpt.has_value()) {
@@ -2846,11 +2964,11 @@ bool TypeSystemParser::parseParentOwner(const ConditionalStreamReader &,
     ArgumentOwner ao;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == indexAttribute()) {
+        if (name == indexAttribute) {
             const QString index = attributes->takeAt(i).value().toString();
             if (!parseArgumentIndex(index, &ao.index, &m_error))
                 return false;
-        } else if (name == actionAttribute()) {
+        } else if (name == actionAttribute) {
             const auto action = attributes->takeAt(i);
             const auto actionOpt = argumentOwnerActionFromAttribute(action.value());
             if (!actionOpt.has_value()) {
@@ -2864,46 +2982,62 @@ bool TypeSystemParser::parseParentOwner(const ConditionalStreamReader &,
     return true;
 }
 
-bool TypeSystemParser::readFileSnippet(QXmlStreamAttributes *attributes, CodeSnip *snip)
+std::optional<TypeSystemParser::Snippet>
+    TypeSystemParser::readFileSnippet(QXmlStreamAttributes *attributes)
 {
-    QString fileName;
-    QString snippetLabel;
+    Snippet result;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == u"file") {
-            fileName = attributes->takeAt(i).value().toString();
-        } else if (name == snippetAttribute()) {
-            snippetLabel = attributes->takeAt(i).value().toString();
+        if (name == fileAttribute) {
+            result.fileName = attributes->takeAt(i).value().toString();
+        } else if (name == snippetAttribute) {
+            result.snippetLabel = attributes->takeAt(i).value().toString();
         }
     }
-    if (fileName.isEmpty())
-        return true;
-    const QString resolved = m_context->db->modifiedTypesystemFilepath(fileName, m_currentPath);
+    if (result.fileName.isEmpty()) {
+        m_error = "Snippet missing file name"_L1;
+        return std::nullopt;
+    }
+    const QString resolved = m_context->db->modifiedTypesystemFilepath(result.fileName,
+                                                                       m_currentPath);
     if (!QFile::exists(resolved)) {
         m_error = u"File for inject code not exist: "_s
-            + QDir::toNativeSeparators(fileName);
-        return false;
+                  + QDir::toNativeSeparators(result.fileName);
+        return std::nullopt;
     }
     QFile codeFile(resolved);
     if (!codeFile.open(QIODevice::Text | QIODevice::ReadOnly)) {
         m_error = msgCannotOpenForReading(codeFile);
-        return false;
+        return std::nullopt;
     }
-    const auto codeOptional = extractSnippet(QString::fromUtf8(codeFile.readAll()), snippetLabel);
+    const auto contentOptional = extractSnippet(QString::fromUtf8(codeFile.readAll()),
+                                                result.snippetLabel);
     codeFile.close();
-    if (!codeOptional.has_value()) {
-        m_error = msgCannotFindSnippet(resolved, snippetLabel);
-        return false;
+    if (!contentOptional.has_value()) {
+        m_error = msgCannotFindSnippet(resolved, result.snippetLabel);
+        return std::nullopt;
     }
+    result.content = contentOptional.value();
+    return result;
+}
+
+bool TypeSystemParser::readCodeSnippet(QXmlStreamAttributes *attributes, CodeSnip *snip)
+{
+    if (!hasFileSnippetAttributes(attributes))
+        return true; // Expecting inline content.
+    const auto snippetOptional = readFileSnippet(attributes);
+    if (!snippetOptional.has_value())
+        return false;
+    const auto snippet = snippetOptional.value();
 
-    QString source = fileName;
-    if (!snippetLabel.isEmpty())
-        source += u" ("_s + snippetLabel + u')';
+    QString source = snippet.fileName;
+    if (!snippet.snippetLabel.isEmpty())
+        source += " ("_L1 + snippet.snippetLabel + u')';
     QString content;
     QTextStream str(&content);
     str << "// ========================================================================\n"
            "// START of custom code block [file: "
-        << source << "]\n" << codeOptional.value()
+        << source << "]\n" << snippet.content
         << "// END of custom code block [file: " << source
         << "]\n// ========================================================================\n";
     snip->addCode(content);
@@ -2925,11 +3059,11 @@ bool TypeSystemParser::parseInjectCode(const ConditionalStreamReader &,
     TypeSystem::CodeSnipPosition position = TypeSystem::CodeSnipPositionBeginning;
     TypeSystem::Language lang = TypeSystem::TargetLangCode;
     CodeSnip snip;
-    if (!readFileSnippet(attributes, &snip))
+    if (!readCodeSnippet(attributes, &snip))
         return false;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == classAttribute()) {
+        if (name == classAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto langOpt = languageFromAttribute(attribute.value());
             if (!langOpt.has_value()) {
@@ -2937,7 +3071,7 @@ bool TypeSystemParser::parseInjectCode(const ConditionalStreamReader &,
                 return false;
             }
             lang = langOpt.value();
-        } else if (name == positionAttribute()) {
+        } else if (name == positionAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto positionOpt = codeSnipPositionFromAttribute(attribute.value());
             if (!positionOpt.has_value()) {
@@ -2961,10 +3095,10 @@ bool TypeSystemParser::parseInjectCode(const ConditionalStreamReader &,
     }
     break;
     case StackElement::Root:
-        qSharedPointerCast<TypeSystemTypeEntry>(m_contextStack.top()->entry)->addCodeSnip(snip);
+        std::static_pointer_cast<TypeSystemTypeEntry>(m_contextStack.top()->entry)->addCodeSnip(snip);
         break;
     default:
-        qSharedPointerCast<ComplexTypeEntry>(m_contextStack.top()->entry)->addCodeSnip(snip);
+        std::static_pointer_cast<ComplexTypeEntry>(m_contextStack.top()->entry)->addCodeSnip(snip);
         break;
     }
     return true;
@@ -2978,9 +3112,9 @@ bool TypeSystemParser::parseInclude(const ConditionalStreamReader &,
     Include::IncludeType location = Include::IncludePath;
     for (auto i = attributes->size() - 1; i >= 0; --i) {
         const auto name = attributes->at(i).qualifiedName();
-        if (name == fileNameAttribute()) {
+        if (name == fileNameAttribute) {
             fileName = attributes->takeAt(i).value().toString();
-        } else if (name == locationAttribute()) {
+        } else if (name == locationAttribute) {
             const auto attribute = attributes->takeAt(i);
             const auto locationOpt = locationFromAttribute(attribute.value());
             if (!locationOpt.has_value()) {
@@ -3010,12 +3144,12 @@ bool TypeSystemParser::parseInclude(const ConditionalStreamReader &,
 bool TypeSystemParser::parseSystemInclude(const ConditionalStreamReader &,
                                           QXmlStreamAttributes *attributes)
 {
-    const auto index = indexOfAttribute(*attributes, fileNameAttribute());
+    const auto index = indexOfAttribute(*attributes, fileNameAttribute);
     if (index == -1) {
-        m_error = msgMissingAttribute(fileNameAttribute());
+        m_error = msgMissingAttribute(fileNameAttribute);
         return false;
     }
-    TypeDatabase::instance()->addSystemInclude(attributes->takeAt(index).value().toString());
+    TypeDatabase::instance()->addForceProcessSystemInclude(attributes->takeAt(index).value().toString());
     return true;
 }
 
@@ -3033,9 +3167,9 @@ TemplateInstance *
                    "conversion-rule, native-to-target or add-conversion tags."_s;
         return nullptr;
     }
-    const auto nameIndex = indexOfAttribute(*attributes, nameAttribute());
+    const auto nameIndex = indexOfAttribute(*attributes, nameAttribute);
     if (nameIndex == -1) {
-        m_error = msgMissingAttribute(nameAttribute());
+        m_error = msgMissingAttribute(nameAttribute);
         return nullptr;
     }
     return new TemplateInstance(attributes->takeAt(nameIndex).value().toString());
@@ -3054,7 +3188,7 @@ bool TypeSystemParser::parseReplace(const ConditionalStreamReader &,
         const auto name = attributes->at(i).qualifiedName();
         if (name == u"from")
             from = attributes->takeAt(i).value().toString();
-        else if (name == toAttribute())
+        else if (name == toAttribute)
             to = attributes->takeAt(i).value().toString();
     }
     m_templateInstance->addReplaceRule(from, to);
@@ -3072,7 +3206,7 @@ bool TypeSystemParser::checkDuplicatedTypeEntry(const ConditionalStreamReader &r
     if (t == StackElement::PrimitiveTypeEntry || t == StackElement::FunctionTypeEntry)
         return true;
     const auto duplicated = m_context->db->findType(name);
-    if (duplicated.isNull() || duplicated->isNamespace())
+    if (!duplicated || duplicated->isNamespace())
         return true;
     if (duplicated->isBuiltIn()) {
         qCWarning(lcShiboken, "%s",
@@ -3110,12 +3244,12 @@ bool TypeSystemParser::startElement(const ConditionalStreamReader &reader, Stack
     VersionRange versionRange;
     for (auto i = attributes.size() - 1; i >= 0; --i) {
         const auto name = attributes.at(i).qualifiedName();
-        if (name == sinceAttribute()) {
+        if (name == sinceAttribute) {
             if (!parseVersion(attributes.takeAt(i).value().toString(),
                               m_defaultPackage, &versionRange.since, &m_error)) {
                 return false;
             }
-        } else if (name == untilAttribute()) {
+        } else if (name == untilAttribute) {
             if (!parseVersion(attributes.takeAt(i).value().toString(),
                               m_defaultPackage, &versionRange.until, &m_error)) {
                 return false;
@@ -3149,7 +3283,7 @@ bool TypeSystemParser::startElement(const ConditionalStreamReader &reader, Stack
     }
 
     if (isTypeEntry(element) || element == StackElement::Root)
-        m_contextStack.push(StackElementContextPtr(new StackElementContext()));
+        m_contextStack.push(std::make_shared<StackElementContext>());
 
     if (m_contextStack.isEmpty()) {
         m_error = msgNoRootTypeSystemEntry();
@@ -3162,11 +3296,11 @@ bool TypeSystemParser::startElement(const ConditionalStreamReader &reader, Stack
     if (isTypeEntry(element)) {
         QString name;
         if (element != StackElement::FunctionTypeEntry) {
-            const auto nameIndex = indexOfAttribute(attributes, nameAttribute());
+            const auto nameIndex = indexOfAttribute(attributes, nameAttribute);
             if (nameIndex != -1) {
                 name = attributes.takeAt(nameIndex).value().toString();
             } else if (element != StackElement::EnumTypeEntry) { // anonymous enum?
-                m_error = msgMissingAttribute(nameAttribute());
+                m_error = msgMissingAttribute(nameAttribute);
                 return false;
             }
         }
@@ -3179,7 +3313,7 @@ bool TypeSystemParser::startElement(const ConditionalStreamReader &reader, Stack
 
         if (m_context->db->hasDroppedTypeEntries()) {
             const QString identifier = element == StackElement::FunctionTypeEntry
-                ? attributes.value(signatureAttribute()).toString() : name;
+                ? attributes.value(signatureAttribute).toString().simplified() : name;
             if (shouldDropTypeEntry(m_context->db, m_contextStack, identifier)) {
                 m_currentDroppedEntryDepth = 1;
                 if (ReportHandler::isDebug(ReportHandler::SparseDebug)) {
@@ -3204,14 +3338,14 @@ bool TypeSystemParser::startElement(const ConditionalStreamReader &reader, Stack
         if (element != StackElement::PrimitiveTypeEntry
             && element != StackElement::FunctionTypeEntry) {
             TypeEntryPtr tmp = m_context->db->findType(name);
-            if (!tmp.isNull() && !tmp->isNamespace())
+            if (tmp && !tmp->isNamespace())
                 qCWarning(lcShiboken).noquote().nospace()
                     << "Duplicate type entry: '" << name << '\'';
         }
 
         if (element == StackElement::EnumTypeEntry) {
             const auto enumIdentifiedByIndex =
-                indexOfAttribute(attributes, enumIdentifiedByValueAttribute());
+                indexOfAttribute(attributes, enumIdentifiedByValueAttribute);
             const QString identifiedByValue = enumIdentifiedByIndex != -1
                 ? attributes.takeAt(enumIdentifiedByIndex).value().toString() : QString();
             if (name.isEmpty()) {
@@ -3270,7 +3404,7 @@ bool TypeSystemParser::startElement(const ConditionalStreamReader &reader, Stack
         case StackElement::InterfaceTypeEntry: {
             if (!checkRootElement())
                 return false;
-            ComplexTypeEntryPtr ce(new ObjectTypeEntry(name, versionRange.since, currentParentTypeEntry()));
+            auto ce = std::make_shared<ObjectTypeEntry>(name, versionRange.since, currentParentTypeEntry());
             top->entry = ce;
             applyCommonAttributes(reader, top->entry, &attributes);
             applyComplexTypeAttributes(reader, ce, &attributes);
@@ -3318,7 +3452,8 @@ bool TypeSystemParser::startElement(const ConditionalStreamReader &reader, Stack
                         || element == StackElement::ConversionRule
                         || element == StackElement::AddFunction
                         || element == StackElement::DeclareFunction
-                        || element == StackElement::Template;
+                        || element == StackElement::Template
+                        || element == StackElement::OpaqueContainer;
 
         if (!topLevel && m_stack.at(m_stack.size() - 2) == StackElement::Root) {
             m_error = u"Tag requires parent: '"_s + tagName.toString() + u'\'';
@@ -3357,12 +3492,12 @@ bool TypeSystemParser::startElement(const ConditionalStreamReader &reader, Stack
 
             const auto topParent = m_stack.value(m_stack.size() - 3, StackElement::None);
             if (isTypeEntry(topParent)) {
-                const auto replaceIndex = indexOfAttribute(attributes, replaceAttribute());
+                const auto replaceIndex = indexOfAttribute(attributes, replaceAttribute);
                 const bool replace = replaceIndex == -1
                     || convertBoolean(attributes.takeAt(replaceIndex).value(),
-                                      replaceAttribute(), true);
+                                      replaceAttribute, true);
                 auto customConversion = CustomConversion::getCustomConversion(top->entry);
-                if (customConversion.isNull()) {
+                if (!customConversion) {
                     m_error = msgMissingCustomConversion(top->entry);
                     return false;
                 }
@@ -3387,14 +3522,17 @@ bool TypeSystemParser::startElement(const ConditionalStreamReader &reader, Stack
                 return false;
             break;
         case StackElement::SuppressedWarning: {
-            const auto textIndex = indexOfAttribute(attributes, textAttribute());
+            const auto textIndex = indexOfAttribute(attributes, textAttribute);
             if (textIndex == -1) {
                 qCWarning(lcShiboken) << "Suppressed warning with no text specified";
             } else {
                 const QString suppressedWarning =
                     attributes.takeAt(textIndex).value().toString();
-                if (!m_context->db->addSuppressedWarning(suppressedWarning, &m_error))
+                if (!m_context->db->addSuppressedWarning(suppressedWarning,
+                                                         m_generate == TypeEntry::GenerateCode,
+                                                         &m_error)) {
                     return false;
+                }
             }
         }
             break;
@@ -3463,17 +3601,19 @@ bool TypeSystemParser::startElement(const ConditionalStreamReader &reader, Stack
                 return false;
             break;
         case StackElement::Rejection:
-            if (!addRejection(m_context->db, &attributes, &m_error))
+            if (!addRejection(m_context->db, m_generate == TypeEntry::GenerateCode,
+                              &attributes, &m_error)) {
                 return false;
+            }
             break;
         case StackElement::SystemInclude:
             if (!parseSystemInclude(reader, &attributes))
                 return false;
             break;
         case StackElement::Template: {
-            const auto nameIndex = indexOfAttribute(attributes, nameAttribute());
+            const auto nameIndex = indexOfAttribute(attributes, nameAttribute);
             if (nameIndex == -1) {
-                m_error = msgMissingAttribute(nameAttribute());
+                m_error = msgMissingAttribute(nameAttribute);
                 return false;
             }
             m_templateEntry.reset(new TemplateEntry(attributes.takeAt(nameIndex).value().toString()));
@@ -3481,13 +3621,19 @@ bool TypeSystemParser::startElement(const ConditionalStreamReader &reader, Stack
             break;
         case StackElement::InsertTemplate:
             m_templateInstance.reset(parseInsertTemplate(reader, topElement, &attributes));
-            if (m_templateInstance.isNull())
+            if (!m_templateInstance)
                 return false;
             break;
         case StackElement::Replace:
             if (!parseReplace(reader, topElement, &attributes))
                 return false;
             break;
+        case StackElement::OpaqueContainer:
+            if (!parseOpaqueContainerElement(&attributes))
+        case StackElement::Configuration:
+            if (!parseConfiguration(topElement, &attributes))
+                return false;
+            break;
         default:
             break; // nada
         }
diff --git a/sources/shiboken6/ApiExtractor/typesystemparser_p.h b/sources/shiboken6/ApiExtractor/typesystemparser_p.h
index 7d47c31e4..4d9d4fd92 100644
--- a/sources/shiboken6/ApiExtractor/typesystemparser_p.h
+++ b/sources/shiboken6/ApiExtractor/typesystemparser_p.h
@@ -4,6 +4,7 @@
 #define TYPESYSTEMPARSER_H
 
 #include "typesystem.h"
+#include "containertypeentry.h"
 #include "typedatabase.h"
 #include "typedatabase_p.h"
 #include "typesystem_typedefs.h"
@@ -12,7 +13,9 @@
 #include <QtCore/QStack>
 #include <QtCore/QHash>
 #include <QtCore/QScopedPointer>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
+#include <optional>
 
 QT_FORWARD_DECLARE_CLASS(QVersionNumber)
 QT_FORWARD_DECLARE_CLASS(QXmlStreamAttributes)
@@ -101,6 +104,8 @@ enum class StackElement {
             ArgumentModifiers,
 
             ImportFile,
+            OpaqueContainer,
+            Configuration,
             Unimplemented
 };
 
@@ -128,12 +133,12 @@ struct StackElementContext
 class TypeSystemParser
 {
 public:
-    Q_DISABLE_COPY(TypeSystemParser)
+    Q_DISABLE_COPY_MOVE(TypeSystemParser)
 
-    using StackElementContextPtr = QSharedPointer<StackElementContext>;
+    using StackElementContextPtr = std::shared_ptr<StackElementContext>;
     using ContextStack = QStack<StackElementContextPtr>;
 
-    explicit TypeSystemParser(const QSharedPointer<TypeDatabaseParserContext> &context,
+    explicit TypeSystemParser(const std::shared_ptr<TypeDatabaseParserContext> &context,
                               bool generate);
     ~TypeSystemParser();
 
@@ -142,6 +147,13 @@ public:
     QString errorString() const { return m_error; }
 
 private:
+    struct Snippet
+    {
+        QString content;
+        QString fileName;
+        QString snippetLabel;
+    };
+
     bool parseXml(ConditionalStreamReader &reader);
     bool setupSmartPointerInstantiations();
     bool startElement(const ConditionalStreamReader &reader, StackElement element);
@@ -166,9 +178,11 @@ private:
     CustomTypeEntryPtr
         parseCustomTypeEntry(const ConditionalStreamReader &, const QString &name,
                              const QVersionNumber &since, QXmlStreamAttributes *);
+    bool parseOpaqueContainers(QStringView s, OpaqueContainers *result);
     ContainerTypeEntryPtr
         parseContainerTypeEntry(const ConditionalStreamReader &, const QString &name,
                                  const QVersionNumber &since, QXmlStreamAttributes *);
+    bool parseOpaqueContainerElement(QXmlStreamAttributes *attributes);
     EnumTypeEntryPtr
         parseEnumTypeEntry(const ConditionalStreamReader &, const QString &name,
                            const QVersionNumber &since, QXmlStreamAttributes *);
@@ -194,6 +208,8 @@ private:
                           const QVersionNumber &since, QXmlStreamAttributes *);
     void applyComplexTypeAttributes(const ConditionalStreamReader &, const ComplexTypeEntryPtr &ctype,
                                     QXmlStreamAttributes *) const;
+    bool parseConfiguration(StackElement topElement,
+                            QXmlStreamAttributes *attributes);
     bool parseRenameFunction(const ConditionalStreamReader &, QString *name,
                              QXmlStreamAttributes *);
     bool parseInjectDocumentation(const ConditionalStreamReader &, StackElement topElement,
@@ -228,6 +244,10 @@ private:
                              StackElement topElement, QXmlStreamAttributes *attributes);
     bool parseProperty(const ConditionalStreamReader &, StackElement topElement,
                        QXmlStreamAttributes *);
+    bool parseBasicModifyFunctionAttributes(QXmlStreamAttributes *,
+                                            FunctionModification *mod);
+    bool parseModifyFunctionAttributes(QXmlStreamAttributes *,
+                                       FunctionModification *mod);
     bool parseModifyFunction(const ConditionalStreamReader &, StackElement topElement,
                              QXmlStreamAttributes *);
     bool parseReplaceDefaultExpression(const ConditionalStreamReader &,
@@ -236,7 +256,8 @@ private:
                               QXmlStreamAttributes *);
      bool parseParentOwner(const ConditionalStreamReader &, StackElement topElement,
                            QXmlStreamAttributes *);
-     bool readFileSnippet(QXmlStreamAttributes *attributes, CodeSnip *snip);
+     std::optional<Snippet> readFileSnippet(QXmlStreamAttributes *attributes);
+     bool readCodeSnippet(QXmlStreamAttributes *attributes, CodeSnip *snip);
      bool parseInjectCode(const ConditionalStreamReader &, StackElement topElement, QXmlStreamAttributes *);
      bool parseInclude(const ConditionalStreamReader &, StackElement topElement,
                        const TypeEntryPtr &entry, QXmlStreamAttributes *);
@@ -251,7 +272,7 @@ private:
      ParserState parserState(qsizetype offset = 0) const;
      CodeSnipAbstract *injectCodeTarget(qsizetype offset = 0) const;
 
-    QSharedPointer<TypeDatabaseParserContext> m_context;
+    std::shared_ptr<TypeDatabaseParserContext> m_context;
     QStack<StackElement> m_stack;
     int m_currentDroppedEntryDepth = 0;
     int m_ignoreDepth = 0;
diff --git a/sources/shiboken6/ApiExtractor/typesystemtypeentry.h b/sources/shiboken6/ApiExtractor/typesystemtypeentry.h
index bd69058d2..9b9670696 100644
--- a/sources/shiboken6/ApiExtractor/typesystemtypeentry.h
+++ b/sources/shiboken6/ApiExtractor/typesystemtypeentry.h
@@ -5,6 +5,7 @@
 #define TYPESYSTEMTYPEENTRY_H
 
 #include "typesystem.h"
+#include "modifications_typedefs.h"
 #include "typesystem_enums.h"
 #include "typesystem_typedefs.h"
 
@@ -23,6 +24,15 @@ public:
     CodeSnipList &codeSnips();
     void addCodeSnip(const CodeSnip &codeSnip);
 
+    QString subModuleOf() const;
+    void setSubModule(const QString &);
+
+    const QString &namespaceBegin() const;
+    void setNamespaceBegin(const QString &n);
+
+    const QString &namespaceEnd() const;
+    void setNamespaceEnd(const QString &n);
+
 protected:
     explicit TypeSystemTypeEntry(TypeEntryPrivate *d);
 };
diff --git a/sources/shiboken6/ApiExtractor/usingmember.h b/sources/shiboken6/ApiExtractor/usingmember.h
index ed362688d..346eab13c 100644
--- a/sources/shiboken6/ApiExtractor/usingmember.h
+++ b/sources/shiboken6/ApiExtractor/usingmember.h
@@ -12,7 +12,7 @@ QT_FORWARD_DECLARE_CLASS(QDebug)
 struct UsingMember // Introducing a base class member via 'using' directive
 {
     QString memberName;
-    const AbstractMetaClass *baseClass;
+    AbstractMetaClassCPtr baseClass;
     Access access;
 };
 
diff --git a/sources/shiboken6/ApiExtractor/xmlutils.cpp b/sources/shiboken6/ApiExtractor/xmlutils.cpp
index b0c9c2084..ccacd4ce7 100644
--- a/sources/shiboken6/ApiExtractor/xmlutils.cpp
+++ b/sources/shiboken6/ApiExtractor/xmlutils.cpp
@@ -21,13 +21,13 @@ QString XQuery::evaluate(QString xPathExpression, QString *errorMessage)
     return doEvaluate(xPathExpression, errorMessage);
 }
 
-QSharedPointer<XQuery> XQuery::create(const QString &focus, QString *errorMessage)
+std::shared_ptr<XQuery> XQuery::create(const QString &focus, QString *errorMessage)
 {
 #if defined(HAVE_LIBXSLT)
     return libXml_createXQuery(focus, errorMessage);
 #else
     *errorMessage = QLatin1StringView(__FUNCTION__) + u" is not implemented."_s;
-    return QSharedPointer<XQuery>();
+    return std::shared_ptr<XQuery>();
 #endif
 }
 
diff --git a/sources/shiboken6/ApiExtractor/xmlutils.h b/sources/shiboken6/ApiExtractor/xmlutils.h
index 2d6adbe9e..ac23c9c9c 100644
--- a/sources/shiboken6/ApiExtractor/xmlutils.h
+++ b/sources/shiboken6/ApiExtractor/xmlutils.h
@@ -3,19 +3,20 @@
 #ifndef XMLUTILS_H
 #define XMLUTILS_H
 
-#include <QtCore/QSharedPointer>
 #include <QtCore/QString>
 
+#include <memory>
+
 class XQuery
 {
 public:
-    Q_DISABLE_COPY(XQuery);
+    Q_DISABLE_COPY_MOVE(XQuery)
 
     virtual ~XQuery();
 
     QString evaluate(QString xPathExpression, QString *errorMessage);
 
-    static QSharedPointer<XQuery> create(const QString &focus, QString *errorMessage);
+    static std::shared_ptr<XQuery> create(const QString &focus, QString *errorMessage);
 
 protected:
     XQuery();
diff --git a/sources/shiboken6/ApiExtractor/xmlutils_libxslt.cpp b/sources/shiboken6/ApiExtractor/xmlutils_libxslt.cpp
index fad8889fa..5a9a26913 100644
--- a/sources/shiboken6/ApiExtractor/xmlutils_libxslt.cpp
+++ b/sources/shiboken6/ApiExtractor/xmlutils_libxslt.cpp
@@ -40,8 +40,6 @@ static void ensureInitialized()
     }
 }
 
-namespace {
-
 // RAI Helpers for cleaning up libxml2/libxslt data
 
 struct XmlDocDeleter // for std::unique_ptr<xmlDoc>
@@ -64,8 +62,6 @@ struct XmlXPathContextDeleter
     void operator()(xmlXPathContextPtr xPathContext) { xmlXPathFreeContext(xPathContext); }
 };
 
-} // namespace
-
 using XmlDocUniquePtr = std::unique_ptr<xmlDoc, XmlDocDeleter>;
 using XmlPathObjectUniquePtr = std::unique_ptr<xmlXPathObject, XmlXPathObjectDeleter>;
 using XmlStyleSheetUniquePtr = std::unique_ptr<xsltStylesheet, XmlStyleSheetDeleter>;
@@ -141,9 +137,10 @@ QString LibXmlXQuery::doEvaluate(const QString &xPathExpression, QString *errorM
     return result;
 }
 
-QSharedPointer<XQuery> libXml_createXQuery(const QString &focus, QString *errorMessage)
+std::shared_ptr<XQuery> libXml_createXQuery(const QString &focus, QString *errorMessage)
 {
-    XmlDocUniquePtr doc(xmlParseFile(QFile::encodeName(focus).constData()));
+    XmlDocUniquePtr doc(xmlReadFile(QFile::encodeName(focus).constData(),
+                        "utf-8", XML_PARSE_NOENT));
     if (!doc) {
         *errorMessage = u"libxml2: Cannot set focus to "_s + QDir::toNativeSeparators(focus);
         return {};
@@ -153,25 +150,27 @@ QSharedPointer<XQuery> libXml_createXQuery(const QString &focus, QString *errorM
         *errorMessage = u"libxml2: xmlXPathNewContext() failed"_s;
         return {};
     }
-    return QSharedPointer<XQuery>(new LibXmlXQuery(doc, xpathContext));
+    return std::shared_ptr<XQuery>(new LibXmlXQuery(doc, xpathContext));
 }
 
 // XSLT transformation
 
-static const char xsltPrefix[] = R"(<?xml version="1.0" encoding="UTF-8" ?>
+static constexpr auto xsltPrefix = R"(<?xml version="1.0" encoding="UTF-8" ?>
     <xsl:transform version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
-)";
+)"_L1;
 
 QString libXslt_transform(const QString &xml, QString xsl, QString *errorMessage)
 {
     ensureInitialized();
     // Read XML data
     if (!xsl.startsWith(u"<?xml")) {
-        xsl.prepend(QLatin1StringView(xsltPrefix));
+        xsl.prepend(xsltPrefix);
         xsl.append(u"</xsl:transform>"_s);
     }
     const QByteArray xmlData = xml.toUtf8();
-    XmlDocUniquePtr xmlDoc(xmlParseMemory(xmlData.constData(), xmlData.size()));
+
+    XmlDocUniquePtr xmlDoc(xmlReadMemory(xmlData.constData(), int(xmlData.size()),
+                                         "", "utf-8", XML_PARSE_NOENT));
     if (!xmlDoc) {
         *errorMessage = u"xmlParseMemory() failed for XML."_s;
         return xml;
diff --git a/sources/shiboken6/ApiExtractor/xmlutils_libxslt.h b/sources/shiboken6/ApiExtractor/xmlutils_libxslt.h
index 3430dce71..0dd8eafcb 100644
--- a/sources/shiboken6/ApiExtractor/xmlutils_libxslt.h
+++ b/sources/shiboken6/ApiExtractor/xmlutils_libxslt.h
@@ -4,11 +4,12 @@
 #define XMLUTILS_LIBXSLT_H
 
 #include <QtCore/QString>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
 
 class XQuery;
 
-QSharedPointer<XQuery> libXml_createXQuery(const QString &focus, QString *errorMessage);
+std::shared_ptr<XQuery> libXml_createXQuery(const QString &focus, QString *errorMessage);
 
 QString libXslt_transform(const QString &xml, QString xsl, QString *errorMessage);
 
diff --git a/sources/shiboken6/ApiExtractor/xmlutils_qt.h b/sources/shiboken6/ApiExtractor/xmlutils_qt.h
index f0c51915f..274827044 100644
--- a/sources/shiboken6/ApiExtractor/xmlutils_qt.h
+++ b/sources/shiboken6/ApiExtractor/xmlutils_qt.h
@@ -4,11 +4,12 @@
 #define XMLUTILS_QT_H
 
 #include <QtCore/QString>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
 
 class XQuery;
 
-QSharedPointer<XQuery> qt_createXQuery(const QString &focus, QString *errorMessage);
+std::shared_ptr<XQuery> qt_createXQuery(const QString &focus, QString *errorMessage);
 
 QString qt_xsl_transform(const QString &xml, QString xsl, QString *errorMessage);
 
diff --git a/sources/shiboken6/CMakeLists.txt b/sources/shiboken6/CMakeLists.txt
index 2f7b23835..9e1bb09b3 100644
--- a/sources/shiboken6/CMakeLists.txt
+++ b/sources/shiboken6/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 Include(icecc.cmake)
 
 cmake_minimum_required(VERSION 3.18)
@@ -7,9 +10,12 @@ set(CMAKE_BUILD_TYPE Release CACHE STRING "Build Type")
 
 include(".cmake.conf")
 project(shiboken6)
-
 include(cmake/ShibokenSetup.cmake)
 
+get_rpath_base_token(base)
+
+set(CMAKE_INSTALL_RPATH ${base}/)
+
 if(SHIBOKEN_BUILD_TOOLS)
     add_subdirectory(ApiExtractor) # Uses libclang
     add_subdirectory(generator) # Uses ApiExtractor And QtCore
diff --git a/sources/shiboken6/cmake/FindDocTools.cmake b/sources/shiboken6/cmake/FindDocTools.cmake
index abf5e5005..621a4ac15 100644
--- a/sources/shiboken6/cmake/FindDocTools.cmake
+++ b/sources/shiboken6/cmake/FindDocTools.cmake
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 find_program(SPHINX_BUILD sphinx-build DOC "Path to sphinx-build binary.")
 
 # graphviz dot appears to be used by sphinx and not by CMake directly. This is just found to check
diff --git a/sources/shiboken6/cmake/ShibokenHelpers.cmake b/sources/shiboken6/cmake/ShibokenHelpers.cmake
index 991026913..cff6df95e 100644
--- a/sources/shiboken6/cmake/ShibokenHelpers.cmake
+++ b/sources/shiboken6/cmake/ShibokenHelpers.cmake
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 include(CMakeParseArguments)
 
 macro(set_limited_api)
@@ -12,7 +15,7 @@ endmacro()
 macro(set_debug_build)
     set(SHIBOKEN_BUILD_TYPE "Debug")
 
-    if(NOT PYTHON_DEBUG_LIBRARIES)
+    if(NOT Python_LIBRARIES)
         message(WARNING "Python debug shared library not found; \
             assuming python was built with shared library support disabled.")
     endif()
@@ -113,7 +116,7 @@ macro(shiboken_internal_set_python_site_packages)
         endif()
     else()
         execute_process(
-            COMMAND ${PYTHON_EXECUTABLE} -c "if True:
+            COMMAND ${Python_EXECUTABLE} -c "if True:
                 import sysconfig
                 from os.path import sep
 
@@ -206,7 +209,7 @@ macro(get_python_extension_suffix)
     else()
         # See PYSIDE-1841 / https://bugs.python.org/issue39825 for distutils vs sysconfig
         execute_process(
-          COMMAND ${PYTHON_EXECUTABLE} -c "if True:
+          COMMAND ${Python_EXECUTABLE} -c "if True:
              import sys
              if sys.version_info >= (3, 8, 2):
                  import sysconfig
@@ -238,18 +241,22 @@ macro(shiboken_check_if_limited_api)
     # TODO: Figure out how to use limited API libs when cross-building to Windows, if that's ever
     # needed. Perhaps use host python to walk the libs of the target python installation.
 
-    if(NOT SHIBOKEN_IS_CROSS_BUILD)
+    if(NOT SHIBOKEN_IS_CROSS_BUILD AND WIN32)
         # On Windows, PYTHON_LIBRARIES can be a list. Example:
         #    optimized;C:/Python36/libs/python36.lib;debug;C:/Python36/libs/python36_d.lib
         # On other platforms, this result is not used at all.
         execute_process(
-            COMMAND ${PYTHON_EXECUTABLE} -c "if True:
-                import os
-                for lib in '${PYTHON_LIBRARIES}'.split(';'):
-                    if '/' in lib and os.path.isfile(lib):
-                        prefix, py = lib.rsplit('/', 1)
+            COMMAND ${Python_EXECUTABLE} -c "if True:
+                from pathlib import Path
+                libs = r'${Python_LIBRARIES}'
+                libs = libs.split(';')
+                for lib in libs:
+                    if ('\\\\' in lib or '/' in lib) and Path(lib).is_file():
+                        lib = Path(lib)
+                        prefix = lib.parent
+                        py = lib.name
                         if py.startswith('python3'):
-                            print(prefix + '/python3.lib')
+                            print(prefix / 'python3.lib')
                             break
                 "
             OUTPUT_VARIABLE PYTHON_LIMITED_LIBRARIES
@@ -268,6 +275,10 @@ endmacro()
 
 
 macro(shiboken_find_required_python)
+    set(_shiboken_find_python_version_args "")
+    if(${ARGC} GREATER 0)
+        list(APPEND _shiboken_find_python_version_args "${ARGV0}")
+    endif()
     # This function can also be called by consumers of ShibokenConfig.cmake package like pyside,
     # that's why we also check for PYSIDE_IS_CROSS_BUILD (which is set by pyside project)
     # and QFP_FIND_NEW_PYTHON_PACKAGE for an explicit opt in.
@@ -275,11 +286,6 @@ macro(shiboken_find_required_python)
     # We have to use FindPython package instead of FindPythonInterp to get required target Python
     # information.
     if(SHIBOKEN_IS_CROSS_BUILD OR PYSIDE_IS_CROSS_BUILD OR QFP_FIND_NEW_PYTHON_PACKAGE)
-        set(_shiboken_find_python_version_args "")
-        if(${ARGC} GREATER 0)
-            list(APPEND _shiboken_find_python_version_args "${ARGV0}")
-        endif()
-
         # We want FindPython to look in the sysroot for the python-config executable,
         # but toolchain files might set CMAKE_FIND_ROOT_PATH_MODE_PROGRAM to NEVER because
         # programs are mostly found for running and you usually can't run a target executable on
@@ -309,39 +315,33 @@ macro(shiboken_find_required_python)
         set(CMAKE_FIND_ROOT_PATH
             "${_shiboken_backup_CMAKE_FIND_ROOT_PATH}")
 
-        # Mirror the variables that FindPythonInterp sets, instead of conditionally checking
-        # and modifying all the places where the variables are used.
-        set(PYTHON_EXECUTABLE "${Python_EXECUTABLE}")
-        set(PYTHON_VERSION "${Python_VERSION}")
-        set(PYTHON_LIBRARIES "${Python_LIBRARIES}")
-        set(PYTHON_INCLUDE_DIRS "${Python_INCLUDE_DIRS}")
-        set(PYTHONINTERP_FOUND "${Python_Interpreter_FOUND}")
-        set(PYTHONINTERP_FOUND "${Python_Interpreter_FOUND}")
-        set(PYTHONLIBS_FOUND "${Python_Development_FOUND}")
-        set(PYTHON_VERSION_MAJOR "${Python_VERSION_MAJOR}")
-        set(PYTHON_VERSION_MINOR "${Python_VERSION_MINOR}")
-        set(PYTHON_VERSION_PATCH "${Python_VERSION_PATCH}")
-    else()
-        if(${ARGC} GREATER 0)
-            find_package(PythonInterp ${ARGV0} REQUIRED)
-            find_package(PythonLibs ${ARGV0} REQUIRED)
-        else()
-            # If no version is specified, just use any interpreter that can be found (from PATH).
-            # This is useful for super-project builds, so that the default system interpeter
-            # gets picked up (e.g. /usr/bin/python and not /usr/bin/python2.7).
-            find_package(PythonInterp REQUIRED)
-            find_package(PythonLibs REQUIRED)
+        # For Android platform sometimes the FindPython module returns Python_SOABI as empty in
+        # certain scenarios eg: armv7a target, macOS host etc. This is because
+        # it is unable to set Python_CONFIG i.e. `python3-config` script
+        # This workaround sets the Python_SOABI manually for this Android platform.
+        # This needs to be updated manually if the Python version for Android cross compilation
+        # changes.
+        # TODO: Find a better way to set Python_SOABI for Android platform
+        if(CMAKE_SYSTEM_NAME STREQUAL "Android" AND NOT Python_SOABI)
+            set(Python_SOABI "cpython-311")
         endif()
+    else()
+        find_package(
+            Python
+            ${_shiboken_find_python_version_args}
+            REQUIRED
+            COMPONENTS Interpreter Development
+        )
     endif()
 
     shiboken_validate_python_version()
 
-    set(SHIBOKEN_PYTHON_INTERPRETER "${PYTHON_EXECUTABLE}")
-    set_property(GLOBAL PROPERTY SHIBOKEN_PYTHON_INTERPRETER "${PYTHON_EXECUTABLE}")
+    set(SHIBOKEN_PYTHON_INTERPRETER "${Python_EXECUTABLE}")
+    set_property(GLOBAL PROPERTY SHIBOKEN_PYTHON_INTERPRETER "${Python_EXECUTABLE}")
 endmacro()
 
 macro(shiboken_validate_python_version)
-    if(PYTHON_VERSION_MAJOR EQUAL "3" AND PYTHON_VERSION_MINOR LESS "7")
+    if(Python_VERSION_MAJOR EQUAL "3" AND Python_VERSION_MINOR LESS "7")
             message(FATAL_ERROR
                    "Shiboken requires Python 3.7+.")
     endif()
@@ -362,14 +362,14 @@ macro(shiboken_compute_python_includes)
     if (SHIBOKEN_COMPUTE_INCLUDES_IS_CALLED_FROM_EXPORT)
         #TODO target_include_directories works on imported targets only starting with v3.11.0.
         set_property(TARGET Shiboken6::libshiboken
-                     APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PYTHON_INCLUDE_DIRS})
+                     APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${Python_INCLUDE_DIRS})
     else()
         target_include_directories(libshiboken
-                                   PUBLIC $<BUILD_INTERFACE:${PYTHON_INCLUDE_DIRS}>)
+                                   PUBLIC $<BUILD_INTERFACE:${Python_INCLUDE_DIRS}>)
     endif()
 
 
-    set(SHIBOKEN_PYTHON_INCLUDE_DIRS "${PYTHON_INCLUDE_DIRS}")
+    set(SHIBOKEN_PYTHON_INCLUDE_DIRS "${Python_INCLUDE_DIRS}")
 
     set_property(GLOBAL PROPERTY shiboken_python_include_dirs "${SHIBOKEN_PYTHON_INCLUDE_DIRS}")
 
@@ -429,16 +429,8 @@ macro(shiboken_compute_python_libraries)
         set(SHIBOKEN_PYTHON_LIBRARIES "")
     endif()
 
-    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-        if(WIN32 AND NOT SHIBOKEN_PYTHON_LIBRARIES)
-            set(SHIBOKEN_PYTHON_LIBRARIES ${PYTHON_DEBUG_LIBRARIES})
-        endif()
-    endif()
-
-    if(CMAKE_BUILD_TYPE STREQUAL "Release")
-        if(WIN32 AND NOT SHIBOKEN_PYTHON_LIBRARIES)
-            set(SHIBOKEN_PYTHON_LIBRARIES ${PYTHON_LIBRARIES})
-        endif()
+    if(WIN32 AND NOT SHIBOKEN_PYTHON_LIBRARIES)
+        set(SHIBOKEN_PYTHON_LIBRARIES ${Python_LIBRARIES})
     endif()
 
     # If the resulting variable
@@ -471,20 +463,20 @@ macro(shiboken_compute_python_libraries)
 endmacro()
 
 function(shiboken_check_if_built_and_target_python_are_compatible)
-    if(NOT SHIBOKEN_PYTHON_VERSION_MAJOR STREQUAL PYTHON_VERSION_MAJOR)
+    if(NOT SHIBOKEN_PYTHON_VERSION_MAJOR STREQUAL Python_VERSION_MAJOR)
         message(FATAL_ERROR "The detected Python major version is not \
 compatible with the Python major version which was used when Shiboken was built.
 Built with: '${SHIBOKEN_PYTHON_VERSION_MAJOR}.${SHIBOKEN_PYTHON_VERSION_MINOR}' \
-Detected: '${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}'")
+Detected: '${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}'")
     else()
         if(NOT SHIBOKEN_PYTHON_LIMITED_API
-           AND NOT SHIBOKEN_PYTHON_VERSION_MINOR STREQUAL PYTHON_VERSION_MINOR)
+           AND NOT SHIBOKEN_PYTHON_VERSION_MINOR STREQUAL Python_VERSION_MINOR)
             message(FATAL_ERROR
                     "The detected Python minor version is not compatible with the Python minor \
 version which was used when Shiboken was built. Consider building shiboken with \
 FORCE_LIMITED_API set to '1', so that only the Python major version matters.
 Built with: '${SHIBOKEN_PYTHON_VERSION_MAJOR}.${SHIBOKEN_PYTHON_VERSION_MINOR}' \
-Detected: '${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}'")
+Detected: '${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}'")
         endif()
     endif()
 endfunction()
@@ -595,6 +587,17 @@ endfunction()
 macro(compute_config_py_values
       full_version_var_name
         )
+    set(QT_MACOS_DEPLOYMENT_TARGET "")
+    if (Qt${QT_MAJOR_VERSION}Core_FOUND)
+        get_target_property(darwin_target Qt6::Core QT_DARWIN_MIN_DEPLOYMENT_TARGET)
+        if(darwin_target)
+            set(QT_MACOS_DEPLOYMENT_TARGET
+                "__qt_macos_min_deployment_target__ = '${darwin_target}'")
+        endif()
+    elseif(APPLE)
+        message(FATAL_ERROR "Qt6::Core should be found before calling this macro")
+    endif()
+
     string(TIMESTAMP PACKAGE_BUILD_DATE "%Y-%m-%dT%H:%M:%S+00:00" UTC)
     if (PACKAGE_BUILD_DATE)
         set(PACKAGE_BUILD_DATE "__build_date__ = '${PACKAGE_BUILD_DATE}'")
@@ -676,16 +679,10 @@ endmacro()
 # tool_name should be a unique tool name, preferably without spaces.
 # Returns the wrapper path in path_out_var.
 #
-# Currently adds the Qt bin dir and the libclang.dll bin dir to PATH.
-# On platforms other than Windows, returs an empty string.
+# Currently adds the Qt lib dir and libclang to PATH / LD_LIBRARY_PATH / DYLD_LIBRARY_PATH.
 # Meant to be used as the first argument to add_custom_command's COMMAND option.
+# TODO: Remove tool_name as the tool_name for this function is always shiboken.
 function(shiboken_get_tool_shell_wrapper tool_name path_out_var)
-    # No need for a wrapper on non Windows hosts.
-    if(NOT CMAKE_HOST_WIN32)
-        set(${path_out_var} "" PARENT_SCOPE)
-        return()
-    endif()
-
     # Generate the wrapper only once during the execution of CMake.
     get_property(is_called GLOBAL PROPERTY "_shiboken_tool_wrapper_${tool_name}_created")
 
@@ -698,28 +695,59 @@ function(shiboken_get_tool_shell_wrapper tool_name path_out_var)
     set(path_dirs "")
     set(path_dirs_native "")
 
+    if(CMAKE_HOST_WIN32)
+        set(wrapper_script_extension ".bat")
+    else()
+        set(wrapper_script_extension ".sh")
+    endif()
+
+    # Try to get original host shiboken paths from exported target properties.
+    shiboken_get_host_tool_wrapper_properties(orig_qt_library_dir_absolute orig_libclang_lib_dir)
+
+    # Get path to the Qt bin/lib dir depending on the platform and developer input.
+    # Prefer values given on the command line, then the original host path if it exists, otherwise
+    # try to use the Qt install prefix and libclang env vars.
+    #
+    # Note that in a cross-compiling case, using the Qt install prefix is very likely
+    # wrong, because you want to use the location of the host Qt, not the target Qt. Same for
+    # libclang. Unfortunately we currently don't provide a host Qt and host libclang option via
+    # setup.py, so the manual cmake vars will have to suffice.
+    if(SHIBOKEN_WRAPPER_HOST_QT_LIB_PATH AND EXISTS "${SHIBOKEN_WRAPPER_HOST_QT_LIB_PATH}")
+        set(qt_library_dir_absolute "${SHIBOKEN_WRAPPER_HOST_QT_LIB_PATH}")
+    elseif(orig_qt_library_dir_absolute AND EXISTS "${orig_qt_library_dir_absolute}")
+        set(qt_library_dir_absolute "${orig_qt_library_dir_absolute}")
+    elseif(CMAKE_HOST_WIN32)
+        # in Windows the Qt dll are store `bin` in directory
+        set(qt_library_dir ${QT6_INSTALL_BINS})
+    else()
+        # in Unix the .so are stored in `lib` directory
+        set(qt_library_dir ${QT6_INSTALL_LIBS})
+    endif()
+
     # Assert that Qt is already found.
-    if(NOT QT6_INSTALL_PREFIX OR NOT QT6_INSTALL_BINS)
+    if((QT6_INSTALL_PREFIX AND qt_library_dir) OR orig_qt_library_dir_absolute)
+    else()
         message(FATAL_ERROR "Qt should have been found already by now.")
     endif()
 
-    # Get path to the Qt bin dir.
-    set(qt_bin_dir "${QT6_INSTALL_PREFIX}/${QT6_INSTALL_BINS}")
-    list(APPEND path_dirs "${qt_bin_dir}")
+    if(NOT qt_library_dir_absolute)
+        set(qt_library_dir_absolute "${QT6_INSTALL_PREFIX}/${qt_library_dir}")
+    endif()
+    list(APPEND path_dirs "${qt_library_dir_absolute}")
 
-    # Get path to libclang.dll.
-    set(libclang_bin_dir "")
-    if(DEFINED ENV{LLVM_INSTALL_DIR})
-        set(libclang_bin_dir "$ENV{LLVM_INSTALL_DIR}/bin")
-    elseif(DEFINED ENV{CLANG_INSTALL_DIR})
-        set(libclang_bin_dir "$ENV{CLANG_INSTALL_DIR}/bin")
+    # Get libclang lib dir path.
+    # Prefer values given on the command line, then the original host path if it exists.
+    if(SHIBOKEN_WRAPPER_HOST_CLANG_LIB_PATH AND EXISTS "${SHIBOKEN_WRAPPER_HOST_CLANG_LIB_PATH}")
+        set(libclang_lib_dir "${SHIBOKEN_WRAPPER_HOST_CLANG_LIB_PATH}")
+    elseif(orig_libclang_lib_dir AND EXISTS "${orig_libclang_lib_dir}")
+        set(libclang_lib_dir "${orig_libclang_lib_dir}")
     else()
-        message(WARNING
-            "Couldn't find libclang.dll. "
-            "You will likely need to add it manually to PATH to ensure the build succeeds.")
+        # find libclang
+        find_libclang()
     endif()
-    if(libclang_bin_dir)
-        list(APPEND path_dirs "${libclang_bin_dir}")
+
+    if(libclang_lib_dir)
+        list(APPEND path_dirs "${libclang_lib_dir}")
     endif()
 
     # Convert the paths from unix-style to native Windows style.
@@ -732,15 +760,130 @@ function(shiboken_get_tool_shell_wrapper tool_name path_out_var)
 
     set(wrapper_dir "${CMAKE_BINARY_DIR}/.qfp/bin")
     file(MAKE_DIRECTORY "${wrapper_dir}")
-    set(wrapper_path "${wrapper_dir}/${tool_name}_wrapper.bat")
+    set(wrapper_path "${wrapper_dir}/${tool_name}_wrapper${wrapper_script_extension}")
 
-    file(WRITE "${wrapper_path}" "@echo off
+    if(CMAKE_HOST_WIN32)
+        file(WRITE "${wrapper_path}" "@echo off
 set PATH=${path_dirs_native};%PATH%
 %*")
+    elseif(CMAKE_HOST_APPLE)
+        string(REPLACE ";" ":" path_dirs_native "${path_dirs_native}")
+        file(WRITE "${wrapper_path}" "#!/bin/bash
+export DYLD_LIBRARY_PATH=${path_dirs_native}:$DYLD_LIBRARY_PATH
+export DYLD_FRAMEWORK_PATH=${path_dirs_native}:$DYLD_FRAMEWORK_PATH
+$@")
+    else()
+        string(REPLACE ";" ":" path_dirs_native "${path_dirs_native}")
+        file(WRITE "${wrapper_path}" "#!/bin/bash
+export LD_LIBRARY_PATH=${path_dirs_native}:$LD_LIBRARY_PATH
+$@")
+    endif()
 
     # Remember the creation of the file for a specific tool.
     set_property(GLOBAL PROPERTY "_shiboken_tool_wrapper_${tool_name}_path" "${wrapper_path}")
     set_property(GLOBAL PROPERTY "_shiboken_tool_wrapper_${tool_name}_created" TRUE)
 
+    # Save original host paths for future cross-builds.
+    shiboken_save_host_tool_wrapper_properties("${qt_library_dir_absolute}" "${libclang_lib_dir}")
+
+    # give execute permission to run the file
+    if(CMAKE_HOST_UNIX)
+        execute_process(COMMAND chmod +x ${wrapper_path})
+    endif()
+
     set(${path_out_var} "${wrapper_path}" PARENT_SCOPE)
 endfunction()
+
+# Retrieve the original host shiboken runtime dependency paths from the installed (namespaced)
+# shiboken generator target.
+function(shiboken_get_host_tool_wrapper_properties out_qt_library_dir out_libclang_lib_dir)
+    if(TARGET Shiboken6::shiboken6)
+        get_target_property(qt_library_dir Shiboken6::shiboken6 _shiboken_original_qt_lib_dir)
+        if(NOT qt_library_dir)
+            set(qt_library_dir "")
+        endif()
+        get_target_property(libclang_lib_dir Shiboken6::shiboken6
+            _shiboken_original_libclang_lib_dir)
+        if(NOT libclang_lib_dir)
+            set(libclang_lib_dir "")
+        endif()
+    endif()
+
+    set(${out_qt_library_dir} "${qt_library_dir}" PARENT_SCOPE)
+    set(${out_libclang_lib_dir} "${libclang_lib_dir}" PARENT_SCOPE)
+endfunction()
+
+# Save original host shiboken runtime dependency paths as target properties, so they can be used
+# when generating the wrapper file for cross-builds.
+# Should only be done when shiboken is being built (aka it's a non-imported target).
+function(shiboken_save_host_tool_wrapper_properties qt_library_dir libclang_lib_dir)
+    if(TARGET shiboken6)
+        get_target_property(is_imported shiboken6 IMPORTED)
+        if(is_imported)
+            return()
+        endif()
+
+        set_target_properties(shiboken6 PROPERTIES
+            _shiboken_original_qt_lib_dir "${qt_library_dir}")
+        set_property(TARGET shiboken6 APPEND PROPERTY
+            EXPORT_PROPERTIES _shiboken_original_qt_lib_dir)
+        if(libclang_lib_dir)
+            set_target_properties(shiboken6 PROPERTIES
+                _shiboken_original_libclang_lib_dir "${libclang_lib_dir}")
+            set_property(TARGET shiboken6 APPEND PROPERTY
+                EXPORT_PROPERTIES _shiboken_original_libclang_lib_dir)
+        endif()
+    endif()
+endfunction()
+
+# Returns the platform-specific relative rpath base token, if it's supported.
+# If it's not supported, returns the string NO_KNOWN_RPATH_REL_BASE.
+function(get_rpath_base_token out_var)
+    if(APPLE)
+        set(rpath_rel_base "@loader_path")
+    elseif(UNIX)
+        set(rpath_rel_base "$ORIGIN")
+    else()
+        #has no effect on Windows
+        set(rpath_rel_base "NO_KNOWN_RPATH_REL_BASE")
+    endif()
+    set(${out_var} "${rpath_rel_base}" PARENT_SCOPE)
+endfunction()
+
+# Get path to libclang.dll/libclang.so depending on the platform
+macro(find_libclang)
+    if(CMAKE_HOST_WIN32)
+        set(libclang_directory_suffix "bin")
+        set(libclang_suffix ".dll")
+    else()
+        set(libclang_directory_suffix "lib")
+        if(CMAKE_HOST_APPLE)
+            set(libclang_suffix ".dylib")
+        else()
+            set(libclang_suffix ".so")
+        endif()
+    endif()
+
+    set(libclang_lib_dir "")
+    if(DEFINED ENV{LLVM_INSTALL_DIR})
+        set(libclang_lib_dir "$ENV{LLVM_INSTALL_DIR}/${libclang_directory_suffix}")
+    elseif(DEFINED ENV{CLANG_INSTALL_DIR})
+        set(libclang_lib_dir "$ENV{CLANG_INSTALL_DIR}/${libclang_directory_suffix}")
+    else()
+        message(WARNING
+            "Couldn't find libclang${libclang_suffix} "
+            "You will likely need to add it manually to PATH to ensure the build succeeds.")
+    endif()
+endmacro()
+
+# Allow setting a shiboken debug level from the the build system or from the environment
+# to all shiboken invocations.
+function(shiboken_get_debug_level out_var)
+    set(debug_level "")
+    if(SHIBOKEN_DEBUG_LEVEL)
+        set(debug_level "--debug-level=${SHIBOKEN_DEBUG_LEVEL}")
+    elseif(DEFINED $ENV{SHIBOKEN_DEBUG_LEVEL})
+        set(debug_level "--debug-level=$ENV{SHIBOKEN_DEBUG_LEVEL}")
+    endif()
+    set(${out_var} "${debug_level}" PARENT_SCOPE)
+endfunction()
diff --git a/sources/shiboken6/cmake/ShibokenSetup.cmake b/sources/shiboken6/cmake/ShibokenSetup.cmake
index 703a72258..32823d9fa 100644
--- a/sources/shiboken6/cmake/ShibokenSetup.cmake
+++ b/sources/shiboken6/cmake/ShibokenSetup.cmake
@@ -1,10 +1,12 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 include(CheckIncludeFileCXX)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
 
 include(ShibokenHelpers)
 
-option(USE_PYTHON_VERSION "Use specific python version to build shiboken6." "")
 option(DISABLE_DOCSTRINGS "Disable documentation extraction." FALSE)
 
 shiboken_internal_disable_pkg_config_if_needed()
@@ -19,7 +21,7 @@ shiboken_internal_set_up_extra_dependency_paths()
 
 set(QT_MAJOR_VERSION 6)
 message(STATUS "Using Qt ${QT_MAJOR_VERSION}")
-find_package(Qt${QT_MAJOR_VERSION} 6.0 REQUIRED COMPONENTS Core)
+find_package(Qt6 REQUIRED COMPONENTS Core)
 
 if(QUIET_BUILD)
     set_quiet_build()
@@ -41,13 +43,12 @@ set(shiboken6_library_so_version "${shiboken_MAJOR_VERSION}.${shiboken_MINOR_VER
 compute_config_py_values(shiboken6_VERSION)
 
 ## For debugging the PYTHON* variables
-message(STATUS "PYTHONLIBS_FOUND:       " ${PYTHONLIBS_FOUND})
-message(STATUS "PYTHON_LIBRARIES:       " ${PYTHON_LIBRARIES})
-message(STATUS "PYTHON_INCLUDE_DIRS:    " ${PYTHON_INCLUDE_DIRS})
-message(STATUS "PYTHON_DEBUG_LIBRARIES: " ${PYTHON_DEBUG_LIBRARIES})
-message(STATUS "PYTHONINTERP_FOUND:     " ${PYTHONINTERP_FOUND})
-message(STATUS "PYTHON_EXECUTABLE:      " ${PYTHON_EXECUTABLE})
-message(STATUS "PYTHON_VERSION:         " ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}.${PYTHON_VERSION_PATCH})
+message(STATUS "Python_Development_FOUND:       " ${Python_Development_FOUND})
+message(STATUS "Python_LIBRARIES:       " ${Python_LIBRARIES})
+message(STATUS "Python_INCLUDE_DIRS:    " ${Python_INCLUDE_DIRS})
+message(STATUS "Python_Interpreter_FOUND:     " ${Python_Interpreter_FOUND})
+message(STATUS "Python_EXECUTABLE:      " ${Python_EXECUTABLE})
+message(STATUS "Python_VERSION:         " ${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}.${Python_VERSION_PATCH})
 
 if(NOT PYTHON_EXTENSION_SUFFIX)
     get_python_extension_suffix()
@@ -118,7 +119,7 @@ endif()
 # Detect if the python libs were compiled in debug mode
 # On Linux distros there is no standard way to check that.
 execute_process(
-    COMMAND ${PYTHON_EXECUTABLE} -c "if True:
+    COMMAND ${Python_EXECUTABLE} -c "if True:
         import sys
         import sysconfig
         config_py_debug = sysconfig.get_config_var('Py_DEBUG')
@@ -136,7 +137,7 @@ if(SHIBOKEN_IS_CROSS_BUILD)
     set(PYTHON_WITH_COUNT_ALLOCS 0)
 else()
     execute_process(
-        COMMAND ${PYTHON_EXECUTABLE} -c "if True:
+        COMMAND ${Python_EXECUTABLE} -c "if True:
             count_allocs = False
             import sys
             try:
diff --git a/sources/shiboken6/cmake_uninstall.cmake b/sources/shiboken6/cmake_uninstall.cmake
index df95fb9d8..4031b4e1a 100644
--- a/sources/shiboken6/cmake_uninstall.cmake
+++ b/sources/shiboken6/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/shiboken6/config.tests/target_python_info/CMakeLists.txt b/sources/shiboken6/config.tests/target_python_info/CMakeLists.txt
index 5ff4c253d..b3f994017 100644
--- a/sources/shiboken6/config.tests/target_python_info/CMakeLists.txt
+++ b/sources/shiboken6/config.tests/target_python_info/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)
 project(proj LANGUAGES CXX)
 
diff --git a/sources/shiboken6/config.tests/target_qt_info/CMakeLists.txt b/sources/shiboken6/config.tests/target_qt_info/CMakeLists.txt
index be4d111dc..7cc6b6ffc 100644
--- a/sources/shiboken6/config.tests/target_qt_info/CMakeLists.txt
+++ b/sources/shiboken6/config.tests/target_qt_info/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)
 project(proj LANGUAGES CXX)
 
diff --git a/sources/shiboken6/config.tests/target_qt_mkspec/CMakeLists.txt b/sources/shiboken6/config.tests/target_qt_mkspec/CMakeLists.txt
index 526570a9c..9f6513316 100644
--- a/sources/shiboken6/config.tests/target_qt_mkspec/CMakeLists.txt
+++ b/sources/shiboken6/config.tests/target_qt_mkspec/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)
 project(dummy LANGUAGES CXX)
 
diff --git a/sources/shiboken6/data/CMakeLists.txt b/sources/shiboken6/data/CMakeLists.txt
index 88d9487da..679eefe6a 100644
--- a/sources/shiboken6/data/CMakeLists.txt
+++ b/sources/shiboken6/data/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
     set(LIBRARY_OUTPUT_SUFFIX ${CMAKE_DEBUG_POSTFIX})
 else()
diff --git a/sources/shiboken6/data/Shiboken6Config-spec.cmake.in b/sources/shiboken6/data/Shiboken6Config-spec.cmake.in
index a07563a53..233404bc6 100644
--- a/sources/shiboken6/data/Shiboken6Config-spec.cmake.in
+++ b/sources/shiboken6/data/Shiboken6Config-spec.cmake.in
@@ -5,9 +5,9 @@
 
 # This is the version of Python against which Shiboken was built. Not necessarily the version
 # against which a downstream project is built (e.g. PySide6).
-set(SHIBOKEN_PYTHON_VERSION_MAJOR "@PYTHON_VERSION_MAJOR@")
-set(SHIBOKEN_PYTHON_VERSION_MINOR "@PYTHON_VERSION_MINOR@")
-set(SHIBOKEN_PYTHON_VERSION_PATCH "@PYTHON_VERSION_PATCH@")
+set(SHIBOKEN_PYTHON_VERSION_MAJOR "@Python_VERSION_MAJOR@")
+set(SHIBOKEN_PYTHON_VERSION_MINOR "@Python_VERSION_MINOR@")
+set(SHIBOKEN_PYTHON_VERSION_PATCH "@Python_VERSION_PATCH@")
 set(SHIBOKEN_PYTHON_LIMITED_API "@PYTHON_LIMITED_API@")
 
 # Import targets and call variable set up functions  only when using an installed shiboken config
@@ -17,7 +17,7 @@ if (NOT TARGET Shiboken6::libshiboken)
     include("${CMAKE_CURRENT_LIST_DIR}/ShibokenHelpers.cmake")
 
     # Compute the python include and libraries path if needed (aka not part of super project build).
-    shiboken_find_required_python(@PYTHON_VERSION_MAJOR@)
+    shiboken_find_required_python(@Python_VERSION_MAJOR@)
     shiboken_check_if_built_and_target_python_are_compatible()
     shiboken_check_if_limited_api()
     shiboken_compute_python_includes(IS_CALLED_FROM_EXPORT)
diff --git a/sources/shiboken6/data/Shiboken6ToolsConfig.cmake.in b/sources/shiboken6/data/Shiboken6ToolsConfig.cmake.in
index 84ccf622f..438b5c651 100644
--- a/sources/shiboken6/data/Shiboken6ToolsConfig.cmake.in
+++ b/sources/shiboken6/data/Shiboken6ToolsConfig.cmake.in
@@ -1,6 +1,6 @@
 @PACKAGE_INIT@
 
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.18)
 
 if(NOT TARGET Shiboken6::shiboken6)
     include("${CMAKE_CURRENT_LIST_DIR}/Shiboken6ToolsTargets.cmake")
diff --git a/sources/shiboken6/data/shiboken6.pc.in b/sources/shiboken6/data/shiboken6.pc.in
index 3ba422627..a82d23168 100644
--- a/sources/shiboken6/data/shiboken6.pc.in
+++ b/sources/shiboken6/data/shiboken6.pc.in
@@ -2,11 +2,11 @@ prefix=@CMAKE_INSTALL_PREFIX@
 exec_prefix=@CMAKE_INSTALL_PREFIX@
 libdir=@CMAKE_INSTALL_PREFIX@/@LIB_INSTALL_DIR@
 includedir=@CMAKE_INSTALL_PREFIX@/include/shiboken6
-python_interpreter=@PYTHON_EXECUTABLE@
-python_include_dir=@PYTHON_INCLUDE_DIRS@
+python_interpreter=@Python_EXECUTABLE@
+python_include_dir=@Python_INCLUDE_DIRS@
 
 Name: shiboken6
 Description: Support library for Python bindings created with the Shiboken6 generator.
 Version: @shiboken6_VERSION@
 Libs: @SHIBOKEN_PYTHON_LIBRARIES@ -L${libdir} -lshiboken6@shiboken6_SUFFIX@@PYTHON_SHARED_LIBRARY_SUFFIX@@LIBRARY_OUTPUT_SUFFIX@
-Cflags: -I@PYTHON_INCLUDE_DIRS@ -I${includedir}/@shiboken6_SUFFIX@@SBK_PKG_CONFIG_PY_DEBUG_DEFINITION@
+Cflags: -I@Python_INCLUDE_DIRS@ -I${includedir}/@shiboken6_SUFFIX@@SBK_PKG_CONFIG_PY_DEBUG_DEFINITION@
diff --git a/sources/shiboken6/doc/CMakeLists.txt b/sources/shiboken6/doc/CMakeLists.txt
index 65b3d4eef..eaef4ff29 100644
--- a/sources/shiboken6/doc/CMakeLists.txt
+++ b/sources/shiboken6/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)
 
 if(FULLDOCSBUILD EQUAL 0)
@@ -34,7 +37,7 @@ if(SPHINX_BUILD)
             if(SHIBOKEN_IS_CROSS_BUILD)
                 set(python_executable "${QFP_PYTHON_HOST_PATH}")
             else()
-                set(python_executable "${PYTHON_EXECUTABLE}")
+                set(python_executable "${Python_EXECUTABLE}")
             endif()
             if(NOT python_executable OR NOT EXISTS "${python_executable}")
                 message(FATAL_ERROR "No python executable found to build documentation.")
diff --git a/sources/shiboken6/doc/_static/css/qt_font.css b/sources/shiboken6/doc/_static/css/qt_font.css
index bc282785e..ce39943ef 100644
--- a/sources/shiboken6/doc/_static/css/qt_font.css
+++ b/sources/shiboken6/doc/_static/css/qt_font.css
@@ -4,6 +4,12 @@
   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("//d33sqmj    vzgs8hq.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");
+  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 */
 }
diff --git a/sources/shiboken6/doc/_static/css/qt_style.css b/sources/shiboken6/doc/_static/css/qt_style.css
index ea40e5107..08c4646c6 100644
--- a/sources/shiboken6/doc/_static/css/qt_style.css
+++ b/sources/shiboken6/doc/_static/css/qt_style.css
@@ -1,37 +1,100 @@
-.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;
+.text-center img {
+    padding-top: 10px;
+    height: 70px !important;
 }
 
-.btn-link:hover {
-  color: #222840 !important;
-  text-decoration: underline;
+.cover-img img {
+  object-fit: cover;
+  height: 50%;
 }
 
-/* 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;
+/* Tables */
+.section .docutils.container td {
+    float:left;
 }
-.card-img-top-main {
-    padding-top: 10px;
-    height: 70px !important;
+
+table.docutils {
+    margin-right: auto;
+    margin-bottom: 10px;
+    border: none;
+    width: initial;
+    font-size: 0.8em;
+}
+
+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;
+}
+
+.hide {
+    display: none;
+}
+
+.fixed .container {
+  max-width:1280px;
+  margin:0 auto;
+  padding:0 3.9%; /* 0? */
+  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;
 }
 
-.card-img-top {
-  object-fit: contain;
-  height: 120px;
-  padding-top: 20px;
-  transform: scale(1.3, 1.3);
+.sd-card-title code span {
+  font-size: +1rem;
+  color: var(--color-brand-primary);
 }
diff --git a/sources/shiboken6/doc/_static/shiboken.png b/sources/shiboken6/doc/_static/shiboken.png
new file mode 100644
index 000000000..587d33329
--- /dev/null
+++ b/sources/shiboken6/doc/_static/shiboken.png
diff --git a/sources/shiboken6/doc/_static/shiboken.svg b/sources/shiboken6/doc/_static/shiboken.svg
new file mode 100644
index 000000000..a13f3e9fb
--- /dev/null
+++ b/sources/shiboken6/doc/_static/shiboken.svg
@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="1080"
+   zoomAndPan="magnify"
+   viewBox="0 0 810 809.999993"
+   height="1080"
+   preserveAspectRatio="xMidYMid meet"
+   version="1.0"
+   id="svg47"
+   sodipodi:docname="shiboken.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">
+  <sodipodi:namedview
+     id="namedview49"
+     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.80648148"
+     inkscape:cx="505.28129"
+     inkscape:cy="540"
+     inkscape:window-width="2552"
+     inkscape:window-height="1432"
+     inkscape:window-x="1924"
+     inkscape:window-y="4"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg47" />
+  <defs
+     id="defs17">
+    <clipPath
+       id="25c649227a">
+      <path
+         d="M 187.234375 180.804688 L 622.011719 180.804688 L 622.011719 615.582031 L 187.234375 615.582031 Z M 187.234375 180.804688 "
+         clip-rule="nonzero"
+         id="path2" />
+    </clipPath>
+    <clipPath
+       id="a7a24c818d">
+      <path
+         d="M 475.953125 479.28125 L 728.5625 479.28125 L 728.5625 731.886719 L 475.953125 731.886719 Z M 475.953125 479.28125 "
+         clip-rule="nonzero"
+         id="path5" />
+    </clipPath>
+    <clipPath
+       id="9e94c67ce5">
+      <path
+         d="M 80.601562 479.28125 L 332.789062 479.28125 L 332.789062 731.886719 L 80.601562 731.886719 Z M 80.601562 479.28125 "
+         clip-rule="nonzero"
+         id="path8" />
+    </clipPath>
+    <clipPath
+       id="f807adb387">
+      <path
+         d="M 475.953125 81.417969 L 728.5625 81.417969 L 728.5625 333.609375 L 475.953125 333.609375 Z M 475.953125 81.417969 "
+         clip-rule="nonzero"
+         id="path11" />
+    </clipPath>
+    <clipPath
+       id="a7b91dab09">
+      <path
+         d="M 80.601562 81.417969 L 332.789062 81.417969 L 332.789062 333.609375 L 80.601562 333.609375 Z M 80.601562 81.417969 "
+         clip-rule="nonzero"
+         id="path14" />
+    </clipPath>
+  </defs>
+  <path
+     fill="#41cb51"
+     d="M 404.621094 459.0625 C 371.058594 459.0625 343.753906 431.75 343.753906 398.195312 C 343.753906 364.628906 371.058594 337.324219 404.621094 337.324219 C 438.179688 337.324219 465.492188 364.628906 465.492188 398.195312 C 465.492188 431.75 438.179688 459.0625 404.621094 459.0625 Z M 404.621094 459.0625 "
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path25" />
+  <g
+     clip-path="url(#25c649227a)"
+     id="g29">
+    <path
+       fill="#41cb51"
+       d="M 614.714844 363.132812 L 568.308594 355.550781 C 564.375 340.4375 558.351562 325.984375 550.351562 312.4375 L 577.464844 273.804688 C 579.890625 270.34375 579.480469 265.648438 576.5 262.65625 L 539.613281 225.769531 C 536.59375 222.742188 531.828125 222.371094 528.386719 224.855469 L 490.152344 252.335938 C 476.578125 244.351562 462.109375 238.34375 447.003906 234.4375 L 438.867188 187.996094 C 438.136719 183.839844 434.519531 180.804688 430.292969 180.804688 L 378.117188 180.804688 C 373.859375 180.804688 370.222656 183.890625 369.535156 188.101562 L 361.953125 234.535156 C 347.023438 238.421875 332.691406 244.371094 319.222656 252.273438 L 280.808594 224.820312 C 277.335938 222.351562 272.617188 222.742188 269.597656 225.742188 L 232.703125 262.628906 C 229.71875 265.613281 229.304688 270.308594 231.730469 273.761719 L 258.851562 312.5 C 250.886719 325.996094 244.902344 340.386719 240.980469 355.402344 L 194.511719 363.140625 C 190.3125 363.835938 187.234375 367.464844 187.234375 371.714844 L 187.234375 423.890625 C 187.234375 428.105469 190.261719 431.714844 194.40625 432.445312 L 240.894531 440.6875 C 244.78125 455.6875 250.746094 470.0625 258.675781 483.582031 L 231.214844 521.964844 C 228.746094 525.425781 229.136719 530.164062 232.136719 533.175781 L 269.023438 570.0625 C 272 573.035156 276.695312 573.453125 280.15625 571.035156 L 318.875 543.9375 C 332.320312 551.878906 346.703125 557.871094 361.78125 561.808594 L 369.535156 608.3125 C 370.242188 612.503906 373.867188 615.582031 378.117188 615.582031 L 430.292969 615.582031 C 434.5 615.582031 438.109375 612.554688 438.847656 608.40625 L 447.101562 561.914062 C 462.292969 557.984375 476.804688 551.949219 490.394531 543.921875 L 529.074219 571.035156 C 532.535156 573.460938 537.230469 573.050781 540.210938 570.070312 L 577.082031 533.183594 C 580.097656 530.164062 580.480469 525.410156 577.984375 521.957031 L 550.480469 483.730469 C 558.464844 470.175781 564.453125 455.714844 568.359375 440.609375 L 614.8125 432.460938 C 618.976562 431.722656 622.011719 428.105469 622.011719 423.890625 L 622.011719 371.714844 C 622.011719 367.453125 618.921875 363.820312 614.714844 363.132812 Z M 404.621094 502.539062 C 347.085938 502.539062 300.277344 455.722656 300.277344 398.183594 C 300.277344 340.65625 347.085938 293.847656 404.621094 293.847656 C 462.160156 293.847656 508.96875 340.65625 508.96875 398.183594 C 508.96875 455.722656 462.160156 502.539062 404.621094 502.539062 Z M 404.621094 502.539062 "
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path27" />
+  </g>
+  <g
+     clip-path="url(#a7a24c818d)"
+     id="g33">
+    <path
+       fill="#ffd43b"
+       d="M 653.035156 479.28125 C 653.035156 576.996094 573.667969 656.363281 475.953125 656.363281 L 475.953125 731.886719 C 615.484375 731.886719 728.5625 618.8125 728.5625 479.28125 Z M 653.035156 479.28125 "
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path31" />
+  </g>
+  <g
+     clip-path="url(#9e94c67ce5)"
+     id="g37">
+    <path
+       fill="#306998"
+       d="M 156.125 479.28125 C 156.125 576.996094 235.492188 656.363281 333.207031 656.363281 L 333.207031 731.886719 C 193.675781 731.886719 80.601562 618.8125 80.601562 479.28125 Z M 156.125 479.28125 "
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path35" />
+  </g>
+  <g
+     clip-path="url(#f807adb387)"
+     id="g41">
+    <path
+       fill="#306998"
+       d="M 653.035156 334.023438 C 653.035156 236.308594 573.667969 156.945312 475.953125 156.945312 L 475.953125 81.417969 C 615.484375 81.417969 728.5625 194.492188 728.5625 334.023438 Z M 653.035156 334.023438 "
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path39" />
+  </g>
+  <g
+     clip-path="url(#a7b91dab09)"
+     id="g45">
+    <path
+       fill="#ffd43b"
+       d="M 156.125 334.023438 C 156.125 236.308594 235.492188 156.945312 333.207031 156.945312 L 333.207031 81.417969 C 193.675781 81.417969 80.601562 194.492188 80.601562 334.023438 Z M 156.125 334.023438 "
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path43" />
+  </g>
+</svg>
diff --git a/sources/shiboken6/doc/_themes/pysidedocs_qthelp/static/pyside.css b/sources/shiboken6/doc/_themes/pysidedocs_qthelp/static/pyside.css
index aee5e4420..94134cacf 100644
--- a/sources/shiboken6/doc/_themes/pysidedocs_qthelp/static/pyside.css
+++ b/sources/shiboken6/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/shiboken6/doc/conf.py.in b/sources/shiboken6/doc/conf.py.in
index ca0b4963b..b10f33b2a 100644
--- a/sources/shiboken6/doc/conf.py.in
+++ b/sources/shiboken6/doc/conf.py.in
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# PyQtB documentation build configuration file, created by
+# Shiboken documentation build configuration file, created by
 # sphinx-quickstart on Wed Apr 22 15:04:20 2009.
 #
 # This file is execfile()d with the current directory set to its containing dir.
@@ -11,34 +11,59 @@
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
-import sys, os
+import sys
+import os
 
 # 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
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#sys.path.append(os.path.abspath('.'))
+# documentation root, use Path(path).resolve() to make it absolute, like shown here.
+sys.path.append('@CMAKE_CURRENT_SOURCE_DIR@')
 
 # -- General configuration -----------------------------------------------------
 
 # 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.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.ifconfig',
-              'sphinx.ext.coverage', 'sphinx_panels', 'sphinx_copybutton']
+    'sphinx.ext.coverage', 'sphinx.ext.intersphinx', 'sphinx.ext.todo',
+    'sphinx.ext.graphviz',
+    'sphinx.ext.viewcode',
+    'sphinx_design', 'sphinx_copybutton',
+    'myst_parser']
+
+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@'
 
 def setup(app):
     app.add_config_value('output_format','qthelp','env')
-rst_epilog = """
 
-.. |project| replace:: Shiboken
+rst_epilog = """
+.. |project| replace:: Qt for Python
+.. |pymodname| replace:: Shiboken6
 """
 
 # Add any paths that contain templates here, relative to this directory.
 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'
@@ -48,16 +73,15 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'Shiboken'
-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.
 #
 # The short X.Y version.
-version = '@shiboken_VERSION@'
+version = '@BINDING_API_VERSION@'
 # The full version, including alpha/beta/rc tags.
-release = '@shiboken_VERSION@'
+release = '@BINDING_API_VERSION_FULL@'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -74,7 +98,8 @@ release = '@shiboken_VERSION@'
 
 # List of directories, relative to source directory, that shouldn't be searched
 # for source files.
-exclude_trees = ['_build']
+exclude_patterns = ['_build',
+                    '**README.md']
 
 # The reST default role (used for this markup: `text`) to use for all documents.
 #default_role = None
@@ -109,16 +134,16 @@ html_theme = 'furo'
 # documentation.
 html_theme_options = {
     "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",
     },
 }
@@ -128,14 +153,14 @@ 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 = None
+html_title = "Shiboken"
 
 # A shorter title for the navigation bar.  Default is the same as html_title.
 #html_short_title = None
 
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
-html_logo = "@CMAKE_CURRENT_SOURCE_DIR@/_static/qtforpython.png"
+html_logo = "@CMAKE_CURRENT_SOURCE_DIR@/_static/shiboken.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
@@ -184,8 +209,3 @@ html_show_sourcelink = False
 
 # -- 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)",
-}
diff --git a/sources/shiboken6/doc/considerations.rst b/sources/shiboken6/doc/considerations.rst
index 1a406c7c9..ad913e7a6 100644
--- a/sources/shiboken6/doc/considerations.rst
+++ b/sources/shiboken6/doc/considerations.rst
@@ -6,6 +6,18 @@ Words of Advice
 
 When writing or using Python bindings there is some things you must keep in mind.
 
+.. _rvalue_references:
+
+Rvalue References
+=================
+
+Normally, no bindings are generated for functions taking rvalue references.
+Experimental support has been added in 6.6. The functions need to be explicitly
+specified using the :ref:`add-function`, :ref:`declare-function` or
+:ref:`function` elements. For :ref:`value-type` objects, this does not have any
+implications since the arguments are copied in the generated code and the copy
+is moved from. For :ref:`object-type` objects however, it means that the object
+instance is moved from and should no longer be referenced.
 
 .. _duck-punching-and-virtual-methods:
 
@@ -18,19 +30,19 @@ be tricky. That was an optimistic statement.
 
 Let's see duck punching in action for educational purposes.
 
-    .. code-block:: python
+.. code-block:: python
 
-       import types
-       import Binding
+   import types
+   import Binding
 
-       obj = Binding.CppClass()
+   obj = Binding.CppClass()
 
-       # CppClass has a virtual method called 'virtualMethod',
-       # but we don't like it anymore.
-       def myVirtualMethod(self_obj, arg):
-           pass
+   # CppClass has a virtual method called 'virtualMethod',
+   # but we don't like it anymore.
+   def myVirtualMethod(self_obj, arg):
+       pass
 
-       obj.virtualMethod = types.MethodType(myVirtualMethod, obj, Binding.CppClass)
+   obj.virtualMethod = types.MethodType(myVirtualMethod, obj, Binding.CppClass)
 
 
 If some C++ code happens to call `CppClass::virtualMethod(...)` on the C++ object
@@ -46,17 +58,17 @@ Python-land by the usage of class constructors, like in the example above.
 
 Brief interruption to show what I was saying:
 
-    .. code-block:: python
+.. code-block:: python
 
-       import types
-       import Binding
+   import types
+   import Binding
 
-       obj = Binding.createCppClass()
-       def myVirtualMethod(self_obj, arg):
-           pass
+   obj = Binding.createCppClass()
+   def myVirtualMethod(self_obj, arg):
+       pass
 
-       # Punching a dead duck...
-       obj.virtualMethod = types.MethodType(myVirtualMethod, obj, Binding.CppClass)
+   # Punching a dead duck...
+   obj.virtualMethod = types.MethodType(myVirtualMethod, obj, Binding.CppClass)
 
 
 The `Binding.createCppClass()` factory method is just an example, C++ created objects
@@ -82,30 +94,30 @@ Below you can check the examples:
 
 Example with old style class:
 
-    .. code-block:: python
+.. code-block:: python
 
-        from PySide6 import QtCore
+    from PySide6 import QtCore
 
-        class MyOldStyleObject:
-            pass
+    class MyOldStyleObject:
+        pass
 
-        class MyObject(QtCore, MyOldStyleObject):
-            pass
+    class MyObject(QtCore, MyOldStyleObject):
+        pass
 
 
 this example will raise a 'TypeError' due to the limitation on PySide, to fix
 this you will need use the new style class:
 
 
-    .. code-block:: python
+.. code-block:: python
 
-        from PySide6 import QtCore
+    from PySide6 import QtCore
 
-        class MyOldStyleObject(object):
-            pass
+    class MyOldStyleObject(object):
+        pass
 
-        class MyObject(QtCore, MyOldStyleObject):
-            pass
+    class MyObject(QtCore, MyOldStyleObject):
+        pass
 
 
 All classes used for multiple inheritance with other PySide types need to have
diff --git a/sources/shiboken6/doc/examples/index.rst b/sources/shiboken6/doc/examples/index.rst
index 92a64195e..e3575bc06 100644
--- a/sources/shiboken6/doc/examples/index.rst
+++ b/sources/shiboken6/doc/examples/index.rst
@@ -4,6 +4,20 @@ Examples
 C++ examples
 ------------
 
-.. toctree::
+.. grid:: 1 4 4 4
+    :gutter: 2
 
-    samplebinding.rst
+    .. grid-item-card:: Sample Binding
+        :class-item: cover-img
+        :link: ../../examples/example_samplebinding_samplebinding.html
+        :img-top: ../images/icecream.png
+
+    .. grid-item-card:: Scriptable Application
+        :class-item: cover-img
+        :link: ../../examples/example_scriptableapplication_scriptableapplication.html
+        :img-top: ../../../_images/example_no_image.png
+
+    .. grid-item-card:: Widget Binding
+        :class-item: cover-img
+        :link: ../../examples/example_widgetbinding_widgetbinding.html
+        :img-top: ../../../_images/example_no_image.png
diff --git a/sources/shiboken6/doc/examples/samplebinding.rst b/sources/shiboken6/doc/examples/samplebinding.rst
deleted file mode 100644
index 17a5bd38f..000000000
--- a/sources/shiboken6/doc/examples/samplebinding.rst
+++ /dev/null
@@ -1,246 +0,0 @@
-SampleBinding Example
-***********************
-
-This example showcases how you can use Shiboken to generate CPython-based
-binding code for a C++ library. The C++ library is called :code:`Universe`,
-with two classes: :code:`Icecream` and :code:`Truck`. Ice-creams are
-characterized by their flavor, and :code:`Truck` serves as a vehicle of
-:code:`Icecream` distribution for kids in a neighborhood.
-
-First, let's look at the definition of the two classes:
-
-.. code-block:: cpp
-   :caption: icecream.h
-
-    class Icecream
-    {
-    public:
-        Icecream(const std::string &flavor);
-        virtual Icecream *clone();
-        virtual ~Icecream();
-        virtual const std::string getFlavor();
-
-    private:
-        std::string m_flavor;
-    };
-
-.. code-block:: cpp
-   :caption: truck.h
-
-    class Truck {
-    public:
-        Truck(bool leaveOnDestruction = false);
-        Truck(const Truck &other);
-        Truck& operator=(const Truck &other);
-        ~Truck();
-
-        void addIcecreamFlavor(Icecream *icecream);
-        void printAvailableFlavors() const;
-
-        bool deliver() const;
-        void arrive() const;
-        void leave() const;
-
-        void setLeaveOnDestruction(bool value);
-        void setArrivalMessage(const std::string &message);
-
-    private:
-        void clearFlavors();
-
-        bool m_leaveOnDestruction = false;
-        std::string m_arrivalMessage = "A new icecream truck has arrived!\n";
-        std::vector m_flavors;
-    };
-
-Here's a summary of what's included in the :code:`Universe` library:
-
-* The :code:`Icecream` polymorphic type, which is intended to be overridden.
-* The :code:`Icecream::getFlavor()` method returns the flavor depending on the
-  actual derived type.
-* The :code:`Truck` value type that contains pointers, hence the copy
-  constructor.
-* :code:`Truck` stores the :code:`Icecream` objects in a vector, which can be
-  modified via :code:`Truck::addIcecreamFlavor()`.
-* The :code:`Truck’s` arrival message can be customized using its
-  :code:`setArrivalMessage()` method.
-* The :code:`Truck::deliver()` method tells us if the ice-cream delivery was
-  successful.
-
-Shiboken typesystem
-====================
-
-Now that the library definitions are in place, the Shiboken generator needs a
-header file that includes the types we are interested in:
-
-.. code-block:: cpp
-   :caption: bindings.h
-
-    #ifndef BINDINGS_H
-    #define BINDINGS_H
-    #include "icecream.h"
-    #include "truck.h"
-    #endif // BINDINGS_H
-
-In addition, Shiboken also requires an XML-based typesystem file that defines the
-relationship between C++ and Python types:
-
-.. code-block:: xml
-   :caption: bindings.xml
-
-    <?xml version="1.0"?>
-    <typesystem package="Universe">
-        <primitive-type name="bool"/>
-        <primitive-type name="std::string"/>
-        <object-type name="Icecream">
-            <modify-function signature="clone()">
-                <modify-argument index="0">
-                    <define-ownership owner="c++"/>
-                </modify-argument>
-            </modify-function>
-        </object-type>
-        <value-type name="Truck">
-            <modify-function signature="addIcecreamFlavor(Icecream*)">
-                <modify-argument index="1">
-                    <define-ownership owner="c++"/>
-                </modify-argument>
-            </modify-function>
-        </value-type>
-    </typesystem>
-
-One important thing to notice here is that we declare :code:`"bool"` and
-:code:`"std::string"` as primitive types. These types are used by some of the
-C++ methods as parameters or return types, so Shiboken must know about them.
-Then, Shiboken can generate relevant conversion code between C++ and Python, although
-most C++ primitive types are handled by Shiboken without additional code.
-
-Next, we declare the two aforementioned classes. One of them as an
-“object-type” and the other as a “value-type”. The main difference is that
-object-types are passed around in generated code as pointers, whereas
-value-types are copied (value semantics).
-
-By specifying the names of these classes in the typesystem file, Shiboken
-automatically tries to generate bindings for all methods of those
-classes. You need not mention all the methods manually in the XML file, unless
-you want to modify them.
-
-Object ownership rules
-=======================
-
-Shiboken doesn't know if Python or C++ are responsible for freeing the C++ objects that were
-allocated in the Python code, and assuming this might lead to errors.
-There can be cases where Python should release the C++ memory when the reference count of the
-Python object becomes zero, but it should never delete the underlying C++ object just from
-assuming that it will not be deleted by underlying C++ library, or if it's maybe parented to
-another object (like QWidgets).
-
-In our case, the :code:`clone()` method is only called inside the C++ library,
-and we assume that the C++ code takes care of releasing the cloned object.
-
-As for :code:`addIcecreamFlavor()`, we know that a :code:`Truck` owns the
-:code:`Icecream` object, and will remove it once the :code:`Truck` is
-destroyed. That's why the ownership is set to “c++” in the typesystem file,
-so that the C++ objects are not deleted when the corresponding Python names
-go out of scope.
-
-Build
-=====
-
-To build the :code:`Universe` custom library and then generate bindings for it,
-use the :file:`CMakeLists.txt` file provided with the example. Later, you can reuse
-the file for your own libraries with minor changes.
-
-Now, run the :command:`"cmake ."` command from the prompt to configure the
-project and build with the toolchain of your choice; we recommend the
-‘(N)Makefiles’ generator.
-
-As a result, you end up with two shared libraries:
-:file:`libuniverse.(so/dylib/dll)` and :file:`Universe.(so/pyd)`. The former is
-the custom C++ library, and the latter is the Python module to import in your
-Python script.
-
-For more details about these platforms, see the :file:`README.md` file.
-
-Use the Python module
-=====================
-
-The following script uses the :code:`Universe` module, derives a few types from
-:code:`Icecream`, implements virtual methods, instantiates objects, and much more:
-
-.. code-block:: python
-   :caption: main.py
-
-    from Universe import Icecream, Truck
-
-    class VanillaChocolateIcecream(Icecream):
-        def __init__(self, flavor=""):
-            super(VanillaChocolateIcecream, self).__init__(flavor)
-
-        def clone(self):
-            return VanillaChocolateIcecream(self.getFlavor())
-
-        def getFlavor(self):
-            return "vanilla sprinked with chocolate"
-
-    class VanillaChocolateCherryIcecream(VanillaChocolateIcecream):
-        def __init__(self, flavor=""):
-            super(VanillaChocolateIcecream, self).__init__(flavor)
-
-        def clone(self):
-            return VanillaChocolateCherryIcecream(self.getFlavor())
-
-        def getFlavor(self):
-            base_flavor = super(VanillaChocolateCherryIcecream, self).getFlavor()
-            return base_flavor + " and a cherry"
-
-    if __name__ == '__main__':
-        leave_on_destruction = True
-        truck = Truck(leave_on_destruction)
-
-        flavors = ["vanilla", "chocolate", "strawberry"]
-        for f in flavors:
-            icecream = Icecream(f)
-            truck.addIcecreamFlavor(icecream)
-
-        truck.addIcecreamFlavor(VanillaChocolateIcecream())
-        truck.addIcecreamFlavor(VanillaChocolateCherryIcecream())
-
-        truck.arrive()
-        truck.printAvailableFlavors()
-        result = truck.deliver()
-
-        if result:
-            print("All the kids got some icecream!")
-        else:
-            print("Aww, someone didn't get the flavor they wanted...")
-
-        if not result:
-            special_truck = Truck(truck)
-            del truck
-
-            print("")
-            special_truck.setArrivalMessage("A new SPECIAL icecream truck has arrived!\n")
-            special_truck.arrive()
-            special_truck.addIcecreamFlavor(Icecream("SPECIAL *magical* icecream"))
-            special_truck.printAvailableFlavors()
-            special_truck.deliver()
-            print("Now everyone got the flavor they wanted!")
-            special_truck.leave()
-
-After importing the classes from the :code:`Universe` module, it derives two
-types from :code:`Icecream` for different “flavors”. It then creates a
-:code:`truck` to deliver some regular flavored Icecreams and two special ones.
-
-If the delivery fails, a new :code:`truck` is created with the old flavors
-copied over, and a new *magical* flavor that will surely satisfy all customers.
-
-Try running it to see if the ice creams are delivered.
-
-.. note::
-    You can find the sources for this example under
-    :file:`<PYTHON_ENV_ROOT>/site-packages/lib/PySide6/examples/samplebinding`.
-
-Refer to the following topics for detailed information about using Shiboken:
- * :doc:`Type System Variables <../typesystem_variables>`
- * :doc:`User Defined Type Conversion <../typesystem_converters>`
- * :doc:`Object ownership <../typesystem_ownership>`
- * :doc:`Considerations and Frequently Asked Questions <../considerations>`
diff --git a/sources/shiboken6/doc/gettingstarted.rst b/sources/shiboken6/doc/gettingstarted.rst
index e59886587..cad49086d 100644
--- a/sources/shiboken6/doc/gettingstarted.rst
+++ b/sources/shiboken6/doc/gettingstarted.rst
@@ -11,11 +11,11 @@ need to continue if you already have a built PySide.
 General Requirements
 ^^^^^^^^^^^^^^^^^^^^
 
- * **Python**: 3.7+
- * **Qt:** 6.0+
- * **libclang:** The libclang library, recommended: version 10 for 6.0+.
-   Prebuilt versions of it can be `downloaded here`_.
- * **CMake:** 3.1+ is needed.
+* **Python**: 3.7+
+* **Qt:** 6.0+
+* **libclang:** The libclang library, recommended: version 10 for 6.0+.
+  Prebuilt versions of it can be `downloaded here`_.
+* **CMake:** 3.1+ is needed.
 
 .. _downloaded here: https://download.qt.io/development_releases/prebuilt/libclang/
 
@@ -40,7 +40,7 @@ The same can be used for the module, changing the value of ``internal-build-type
 ``shiboken6-module``.
 
 .. warning:: If you are planning to use PySide too, for examples like
-    'scriptableapplication' you need to have build it as well.  The main issue is
+    'scriptableapplication' you need to have build it as well. The main issue is
     that your PySide and Shiboken needs to be build using the same dependencies
     from Qt and libclang.
 
diff --git a/sources/shiboken6/doc/images/boostgen.png b/sources/shiboken6/doc/images/boostgen.png
deleted file mode 100644
index ae9d9fc3d..000000000
--- a/sources/shiboken6/doc/images/boostgen.png
+++ /dev/null
diff --git a/sources/shiboken6/doc/images/converter.png b/sources/shiboken6/doc/images/converter.png
index cd52e2769..3935fdc60 100644
--- a/sources/shiboken6/doc/images/converter.png
+++ b/sources/shiboken6/doc/images/converter.png
diff --git a/sources/shiboken6/doc/images/converter.svg b/sources/shiboken6/doc/images/converter.svg
index 4305eb720..2df5c88e5 100644
--- a/sources/shiboken6/doc/images/converter.svg
+++ b/sources/shiboken6/doc/images/converter.svg
@@ -1,349 +1,2227 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
 <svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   width="908.50861"
+   zoomAndPan="magnify"
+   viewBox="0 0 681.38145 434.11857"
+   height="578.82477"
+   preserveAspectRatio="xMidYMid"
+   version="1.0"
+   id="svg5080"
+   sodipodi:docname="converter.svg"
+   inkscape:version="1.2.2 (b0a8486541, 2022-12-01)"
    xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="206.375mm"
-   height="100.54167mm"
-   viewBox="0 0 206.375 100.54167"
-   version="1.1"
-   id="svg8"
-   inkscape:version="0.92.2 2405546, 2018-03-11"
-   sodipodi:docname="converter.svg">
+   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">
+  <sodipodi:namedview
+     id="namedview5082"
+     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.80648148"
+     inkscape:cx="413.52468"
+     inkscape:cy="205.2124"
+     inkscape:window-width="2552"
+     inkscape:window-height="1432"
+     inkscape:window-x="1924"
+     inkscape:window-y="4"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg5080" />
   <defs
-     id="defs2">
-    <marker
-       inkscape:isstock="true"
-       style="overflow:visible"
-       id="marker1623"
-       refX="0"
-       refY="0"
-       orient="auto"
-       inkscape:stockid="Arrow1Lend">
+     id="defs4108">
+    <g
+       id="g4028" />
+    <clipPath
+       id="24985ca8b2">
+      <path
+         d="m 325.10547,297.75 h 159.75 V 405 h -159.75 z m 0,0"
+         clip-rule="nonzero"
+         id="path4030" />
+    </clipPath>
+    <clipPath
+       id="3cea3902db">
+      <path
+         d="m 382.58984,359.24609 h 18 v 11.25 h -18 z m 0,0"
+         clip-rule="nonzero"
+         id="path4033" />
+    </clipPath>
+    <clipPath
+       id="dfab995897">
+      <path
+         d="m 325.10547,473.32031 h 159.75 v 107.25 h -159.75 z m 0,0"
+         clip-rule="nonzero"
+         id="path4036" />
+    </clipPath>
+    <clipPath
+       id="2d1327caba">
+      <path
+         d="m 411.91016,534.82031 h 18 v 11.25 h -18 z m 0,0"
+         clip-rule="nonzero"
+         id="path4039" />
+    </clipPath>
+    <clipPath
+       id="f03e985e13">
+      <path
+         d="m 113,313.11719 h 113.76172 v 76.5 H 113 Z m 0,0"
+         clip-rule="nonzero"
+         id="path4042" />
+    </clipPath>
+    <clipPath
+       id="c71ef1b2fa">
+      <path
+         d="m 112.76172,313.11719 h 114 v 76.5 h -114 z m 0,0"
+         clip-rule="nonzero"
+         id="path4045" />
+    </clipPath>
+    <clipPath
+       id="3bddcdf684">
+      <path
+         d="m 593.35156,488.69141 h 114 v 76.5 h -114 z m 0,0"
+         clip-rule="nonzero"
+         id="path4048" />
+    </clipPath>
+    <clipPath
+       id="cd19a8dfa8">
+      <path
+         d="m 588,313.11719 h 113.98828 v 76.5 H 588 Z m 0,0"
+         clip-rule="nonzero"
+         id="path4051" />
+    </clipPath>
+    <clipPath
+       id="61b05d6a70">
+      <path
+         d="m 125,427 h 89.71094 v 60 H 125 Z m 0,0"
+         clip-rule="nonzero"
+         id="path4054" />
+    </clipPath>
+    <clipPath
+       id="ea42d02648">
+      <path
+         d="m 124.77344,426.82031 h 89.9375 v 60.35547 h -89.9375 z m 0,0"
+         clip-rule="nonzero"
+         id="path4057" />
+    </clipPath>
+    <clipPath
+       id="84bd6662f0">
+      <path
+         d="m 125,497 h 89.71094 v 60 H 125 Z m 0,0"
+         clip-rule="nonzero"
+         id="path4060" />
+    </clipPath>
+    <clipPath
+       id="728d290ff8">
+      <path
+         d="m 124.77344,496.94922 h 89.9375 v 60.35547 h -89.9375 z m 0,0"
+         clip-rule="nonzero"
+         id="path4063" />
+    </clipPath>
+    <clipPath
+       id="00b091b271">
       <path
-         transform="matrix(-0.8,0,0,-0.8,-10,0)"
-         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1"
-         d="M 0,0 5,-5 -12.5,0 5,5 Z"
-         id="path1621"
-         inkscape:connector-curvature="0" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Lend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="marker1569"
-       style="overflow:visible"
-       inkscape:isstock="true"
-       inkscape:collect="always">
+         d="m 125,567 h 89.71094 v 60 H 125 Z m 0,0"
+         clip-rule="nonzero"
+         id="path4066" />
+    </clipPath>
+    <clipPath
+       id="be13ebcaaa">
       <path
-         id="path1567"
-         d="M 0,0 5,-5 -12.5,0 5,5 Z"
-         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1"
-         transform="matrix(-0.8,0,0,-0.8,-10,0)"
-         inkscape:connector-curvature="0" />
-    </marker>
-    <marker
-       inkscape:isstock="true"
-       style="overflow:visible"
-       id="marker1521"
-       refX="0"
-       refY="0"
-       orient="auto"
-       inkscape:stockid="Arrow1Lend"
-       inkscape:collect="always">
+         d="m 124.77344,566.78125 h 89.9375 v 60.35156 h -89.9375 z m 0,0"
+         clip-rule="nonzero"
+         id="path4069" />
+    </clipPath>
+    <clipPath
+       id="12ef88673f">
       <path
-         transform="matrix(-0.8,0,0,-0.8,-10,0)"
-         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1"
-         d="M 0,0 5,-5 -12.5,0 5,5 Z"
-         id="path1519"
-         inkscape:connector-curvature="0" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Lend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="marker1479"
-       style="overflow:visible"
-       inkscape:isstock="true"
-       inkscape:collect="always">
+         d="m 242.54687,336.47266 h 66 v 30 h -66 z m 0,0"
+         clip-rule="nonzero"
+         id="path4072" />
+    </clipPath>
+    <clipPath
+       id="4425bd08fe">
       <path
-         id="path1477"
-         d="M 0,0 5,-5 -12.5,0 5,5 Z"
-         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1"
-         transform="matrix(-0.8,0,0,-0.8,-10,0)"
-         inkscape:connector-curvature="0" />
-    </marker>
-    <marker
-       inkscape:isstock="true"
-       style="overflow:visible"
-       id="marker1443"
-       refX="0"
-       refY="0"
-       orient="auto"
-       inkscape:stockid="Arrow1Lend"
-       inkscape:collect="always">
+         d="m 503.92969,336.47266 h 66 v 30 h -66 z m 0,0"
+         clip-rule="nonzero"
+         id="path4075" />
+    </clipPath>
+    <clipPath
+       id="29f410bb45">
       <path
-         transform="matrix(-0.8,0,0,-0.8,-10,0)"
-         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1"
-         d="M 0,0 5,-5 -12.5,0 5,5 Z"
-         id="path1441"
-         inkscape:connector-curvature="0" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Lend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Lend"
-       style="overflow:visible"
-       inkscape:isstock="true"
-       inkscape:collect="always">
+         d="m 503.92969,512.04297 h 66 v 30 h -66 z m 0,0"
+         clip-rule="nonzero"
+         id="path4078" />
+    </clipPath>
+    <clipPath
+       id="8612924f50">
       <path
-         id="path1154"
-         d="M 0,0 5,-5 -12.5,0 5,5 Z"
-         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1"
-         transform="matrix(-0.8,0,0,-0.8,-10,0)"
-         inkscape:connector-curvature="0" />
-    </marker>
+         d="m 236.54297,511.73437 h 66 v 30 h -66 z m 0,0"
+         clip-rule="nonzero"
+         id="path4081" />
+    </clipPath>
+    <clipPath
+       id="9616827f5c">
+      <path
+         d="m 238,451 h 62 v 38 h -62 z m 0,0"
+         clip-rule="nonzero"
+         id="path4084" />
+    </clipPath>
+    <clipPath
+       id="6d6215aef9">
+      <path
+         d="m 246.00781,440.04297 59.81641,27.89453 -12.67969,27.1875 -59.81641,-27.89063 z m 0,0"
+         clip-rule="nonzero"
+         id="path4087" />
+    </clipPath>
+    <clipPath
+       id="506e24dd3d">
+      <path
+         d="m 246.00781,440.04297 59.81641,27.89453 -12.67969,27.1875 -59.81641,-27.89063 z m 0,0"
+         clip-rule="nonzero"
+         id="path4090" />
+    </clipPath>
+    <clipPath
+       id="85c10bb5f0">
+      <path
+         d="m 246.00781,440.04297 59.81641,27.89453 -12.67969,27.1875 -59.81641,-27.89063 z m 0,0"
+         clip-rule="nonzero"
+         id="path4093" />
+    </clipPath>
+    <clipPath
+       id="96382ab88a">
+      <path
+         d="m 238,565 h 62 v 38 h -62 z m 0,0"
+         clip-rule="nonzero"
+         id="path4096" />
+    </clipPath>
+    <clipPath
+       id="8ee2f579d3">
+      <path
+         d="m 233.26953,586.86719 59.81641,-27.89063 12.67578,27.1875 -59.81641,27.89453 z m 0,0"
+         clip-rule="nonzero"
+         id="path4099" />
+    </clipPath>
+    <clipPath
+       id="c24345751d">
+      <path
+         d="m 246.00781,614.18359 59.81641,-27.89062 -12.67969,-27.19141 -59.81641,27.89453 z m 0,0"
+         clip-rule="nonzero"
+         id="path4102" />
+    </clipPath>
+    <clipPath
+       id="6c1dc82097">
+      <path
+         d="m 246.00781,614.18359 59.81641,-27.89062 -12.67969,-27.19141 -59.81641,27.89453 z m 0,0"
+         clip-rule="nonzero"
+         id="path4105" />
+    </clipPath>
   </defs>
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="0.35"
-     inkscape:cx="382.16184"
-     inkscape:cy="-28.417621"
-     inkscape:document-units="mm"
-     inkscape:current-layer="layer1"
-     showgrid="true"
-     fit-margin-top="0"
-     fit-margin-left="0"
-     fit-margin-right="0"
-     fit-margin-bottom="0"
-     inkscape:window-width="1002"
-     inkscape:window-height="1042"
-     inkscape:window-x="10"
-     inkscape:window-y="28"
-     inkscape:window-maximized="0">
-    <inkscape:grid
-       type="xygrid"
-       id="grid971"
-       originx="-58.208333"
-       originy="-68.791657" />
-  </sodipodi:namedview>
-  <metadata
-     id="metadata5">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(-58.208333,-127.66667)">
+  <rect
+     x="-1.4210855e-14"
+     width="681.38147"
+     fill="#ffffff"
+     y="-2.8421709e-14"
+     height="434.11859"
+     fill-opacity="1"
+     id="rect4110"
+     style="stroke-width:0.559543" />
+  <path
+     fill="#41cb51"
+     d="M 256.85164,139.32657 V 62.127352 c 0,-0.9336 0.0898,-1.85938 0.27344,-2.77344 0.17968,-0.91406 0.44922,-1.80078 0.80468,-2.66406 0.35547,-0.86328 0.79297,-1.67969 1.3086,-2.45703 0.51562,-0.77344 1.10547,-1.49219 1.76172,-2.15235 0.65625,-0.66015 1.37109,-1.25 2.14453,-1.76562 0.77344,-0.51953 1.58984,-0.95703 2.44922,-1.3125 0.85937,-0.35938 1.74218,-0.62891 2.65625,-0.8086 0.91015,-0.18359 1.83203,-0.27343 2.76172,-0.27343 h 129.44531 c 0.92969,0 1.85156,0.0898 2.76172,0.27343 0.91406,0.17969 1.79687,0.44922 2.65625,0.8086 0.85937,0.35547 1.67578,0.79297 2.44922,1.3125 0.77343,0.51562 1.48828,1.10547 2.14453,1.76562 0.66015,0.66016 1.24609,1.37891 1.76172,2.15235 0.51562,0.77734 0.95312,1.59375 1.30859,2.45703 0.35547,0.86328 0.625,1.75 0.80469,2.66406 0.18359,0.91406 0.27343,1.83984 0.27343,2.77344 v 77.199218 c 0,0.93359 -0.0898,1.85937 -0.27343,2.77343 -0.17969,0.91407 -0.44922,1.80469 -0.80469,2.66407 -0.35547,0.86328 -0.79297,1.68359 -1.30859,2.45703 -0.51563,0.77734 -1.10157,1.49218 -1.76172,2.15234 -0.65625,0.66016 -1.3711,1.25 -2.14453,1.76953 -0.77344,0.51563 -1.58985,0.95313 -2.44922,1.3125 -0.85938,0.35547 -1.74219,0.625 -2.65625,0.8086 -0.91016,0.17968 -1.83203,0.27343 -2.76172,0.27343 H 271.0118 c -0.92969,0 -1.85157,-0.0937 -2.76172,-0.27343 -0.91407,-0.1836 -1.79688,-0.45313 -2.65625,-0.8086 -0.85938,-0.35937 -1.67578,-0.79687 -2.44922,-1.3125 -0.77344,-0.51953 -1.48828,-1.10937 -2.14453,-1.76953 -0.65625,-0.66016 -1.2461,-1.375 -1.76172,-2.15234 -0.51563,-0.77344 -0.95313,-1.59375 -1.3086,-2.45703 -0.35546,-0.85938 -0.625,-1.75 -0.80468,-2.66407 -0.1836,-0.91406 -0.27344,-1.83984 -0.27344,-2.77343 z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path4116" />
+  <g
+     clip-path="url(#24985ca8b2)"
+     id="g4120"
+     transform="translate(-69.242111,-250.64609)">
+    <path
+       fill="#41cb51"
+       d="m 484.67187,312.77344 v 77.19922 c 0,0.98437 -0.0937,1.96093 -0.28515,2.92968 -0.19531,0.96875 -0.47656,1.90625 -0.85547,2.82032 -0.375,0.91015 -0.83594,1.77734 -1.38281,2.59765 -0.54688,0.82031 -1.16797,1.57813 -1.86328,2.27735 -0.69532,0.69531 -1.44922,1.32031 -2.26954,1.86718 -0.8164,0.55078 -1.67968,1.01172 -2.58984,1.39063 -0.90625,0.375 -1.84375,0.66015 -2.80859,0.85547 -0.96485,0.1914 -1.9375,0.28906 -2.92188,0.28906 h -129.4375 c -0.98437,0 -1.95703,-0.0977 -2.92187,-0.28906 -0.96485,-0.19532 -1.90235,-0.48047 -2.8086,-0.85547 -0.91015,-0.37891 -1.77343,-0.83985 -2.58984,-1.39063 -0.82031,-0.54687 -1.57422,-1.17187 -2.26953,-1.86718 -0.69531,-0.69922 -1.31641,-1.45704 -1.86328,-2.27735 -0.54688,-0.82031 -1.00782,-1.6875 -1.38282,-2.59765 -0.3789,-0.91407 -0.66015,-1.85157 -0.85546,-2.82032 -0.19141,-0.96875 -0.28516,-1.94531 -0.28516,-2.92968 v -77.19922 c 0,-0.98828 0.0937,-1.96485 0.28516,-2.9336 0.19531,-0.96484 0.47656,-1.90625 0.85546,-2.8164 0.375,-0.91407 0.83594,-1.77735 1.38282,-2.59766 0.54687,-0.82422 1.16797,-1.58203 1.86328,-2.27734 0.69531,-0.69922 1.44922,-1.32422 2.26953,-1.8711 0.81641,-0.54687 1.67969,-1.01172 2.58984,-1.38672 0.90625,-0.3789 1.84375,-0.66406 2.8086,-0.85546 0.96484,-0.19532 1.9375,-0.28907 2.92187,-0.28907 h 129.44141 c 0.98437,0 1.95703,0.0977 2.92187,0.28907 0.96485,0.1914 1.90235,0.47656 2.8086,0.85546 0.91015,0.37891 1.76953,0.83985 2.58984,1.38672 0.81641,0.55078 1.57422,1.17188 2.26953,1.8711 0.69531,0.69531 1.3125,1.45703 1.85938,2.27734 0.54687,0.82031 1.00781,1.68359 1.38281,2.59766 0.37891,0.91015 0.66406,1.85156 0.85547,2.8164 0.1914,0.96875 0.28515,1.94532 0.28515,2.9336 z m -157.76171,77.19922 c 0,0.8789 0.082,1.75 0.2539,2.61328 0.17188,0.85937 0.42578,1.69922 0.76172,2.51172 0.33594,0.8125 0.74609,1.58203 1.23047,2.3164 0.48828,0.73047 1.04297,1.40625 1.66016,2.02735 0.62109,0.62109 1.29687,1.17968 2.02343,1.66796 0.73047,0.48829 1.5,0.89844 2.3086,1.23438 0.80859,0.33984 1.64453,0.59375 2.5039,0.76562 0.85938,0.17188 1.72657,0.25391 2.60547,0.25391 h 129.44141 c 0.875,0 1.74609,-0.082 2.60547,-0.25391 0.85937,-0.17187 1.69531,-0.42578 2.5039,-0.76562 0.8086,-0.33594 1.57813,-0.74609 2.3086,-1.23438 0.72656,-0.48828 1.40234,-1.04687 2.01953,-1.66796 0.62109,-0.6211 1.17578,-1.29688 1.66015,-2.02735 0.48829,-0.73437 0.89844,-1.5039 1.23438,-2.3164 0.33594,-0.8125 0.58984,-1.65235 0.76172,-2.51172 0.16797,-0.86328 0.2539,-1.73438 0.2539,-2.61328 v -77.19922 c 0,-0.87891 -0.0859,-1.75 -0.2539,-2.61328 -0.17188,-0.86329 -0.42578,-1.69922 -0.76172,-2.51172 -0.33594,-0.8125 -0.74609,-1.58594 -1.23438,-2.31641 -0.48437,-0.73047 -1.03906,-1.41016 -1.66015,-2.03125 -0.61719,-0.62109 -1.29297,-1.17578 -2.01953,-1.66406 -0.73047,-0.48828 -1.5,-0.90235 -2.3086,-1.23828 -0.80859,-0.33594 -1.64453,-0.58985 -2.5039,-0.76172 -0.85938,-0.17188 -1.73047,-0.25781 -2.60547,-0.25781 H 340.25781 c -0.8789,0 -1.74609,0.0859 -2.60547,0.25781 -0.85937,0.17187 -1.69531,0.42578 -2.5039,0.76172 -0.8086,0.33593 -1.57813,0.75 -2.3086,1.23828 -0.72656,0.48828 -1.40234,1.04297 -2.02343,1.66406 -0.61719,0.62109 -1.17188,1.30078 -1.66016,2.03125 -0.48438,0.73047 -0.89453,1.50391 -1.23047,2.31641 -0.33594,0.8125 -0.58984,1.64843 -0.76172,2.51172 -0.17187,0.86328 -0.2539,1.73437 -0.2539,2.61328 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4118" />
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4128"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(334.04375,371.84414)"
+       id="g4126">
+      <g
+         id="g4124">
+        <path
+           d="M 11.0625,-0.234375 C 9.550781,0.0664062 8.191406,0.21875 6.984375,0.21875 5.785156,0.21875 4.816406,0.0546875 4.078125,-0.265625 3.335938,-0.597656 2.765625,-1.113281 2.359375,-1.8125 1.960938,-2.507812 1.6875,-3.304688 1.53125,-4.203125 c -0.15625,-0.90625 -0.234375,-2.03125 -0.234375,-3.375 0,-1.351563 0.078125,-2.488281 0.234375,-3.40625 0.15625,-0.914063 0.429688,-1.722656 0.828125,-2.421875 0.40625,-0.707031 0.972656,-1.222656 1.703125,-1.546875 0.738281,-0.320313 1.691406,-0.484375 2.859375,-0.484375 1.175781,0 2.554687,0.164062 4.140625,0.484375 L 11,-13.53125 c -1.480469,-0.257812 -2.796875,-0.390625 -3.953125,-0.390625 -1.617187,0 -2.683594,0.480469 -3.203125,1.4375 -0.523438,0.960937 -0.78125,2.601563 -0.78125,4.921875 0,1.15625 0.046875,2.089844 0.140625,2.796875 0.09375,0.699219 0.28125,1.328125 0.5625,1.890625 0.28125,0.5625 0.6875,0.96875 1.21875,1.21875 0.53125,0.242188 1.3125,0.359375 2.34375,0.359375 1.039063,0 2.265625,-0.128906 3.671875,-0.390625 z m 0,0"
+           id="path4122" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4136"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(346.00962,371.84414)"
+       id="g4134">
+      <g
+         id="g4132">
+        <path
+           d="M 1.203125,-4.78125 V -6.265625 H 5.375 V -10.5625 h 1.53125 v 4.296875 h 4.203125 V -4.78125 H 6.90625 V -0.4375 H 5.375 v -4.34375 z m 0,0"
+           id="path4130" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4144"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(358.32742,371.84414)"
+       id="g4142">
+      <g
+         id="g4140">
+        <path
+           d="M 1.203125,-4.78125 V -6.265625 H 5.375 V -10.5625 h 1.53125 v 4.296875 h 4.203125 V -4.78125 H 6.90625 V -0.4375 H 5.375 v -4.34375 z m 0,0"
+           id="path4138" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4150"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(370.6414,371.84414)"
+       id="g4148">
+      <g
+         id="g4146" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4156"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(375.48053,371.84414)"
+       id="g4154">
+      <g
+         id="g4152" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4162"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(380.31967,371.84414)"
+       id="g4160">
+      <g
+         id="g4158" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4168"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(385.1588,371.84414)"
+       id="g4166">
+      <g
+         id="g4164" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4174"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(389.99794,371.84414)"
+       id="g4172">
+      <g
+         id="g4170" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4180"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(394.83707,371.84414)"
+       id="g4178">
+      <g
+         id="g4176" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4186"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(399.6762,371.84414)"
+       id="g4184">
+      <g
+         id="g4182" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4192"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(404.51534,371.84414)"
+       id="g4190">
+      <g
+         id="g4188" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4200"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(409.34843,371.84414)"
+       id="g4198">
+      <g
+         id="g4196">
+        <path
+           d="M 7.4375,-5.125 H 3.5625 V 0 H 1.875 v -15.21875 h 5.5625 c 1.65625,0 2.878906,0.40625 3.671875,1.21875 0.789063,0.804688 1.1875,2.03125 1.1875,3.6875 0,3.460938 -1.621094,5.1875 -4.859375,5.1875 z m -3.875,-1.5 h 3.84375 c 2.101562,0 3.15625,-1.226562 3.15625,-3.6875 0,-1.175781 -0.25,-2.039062 -0.75,-2.59375 -0.5,-0.550781 -1.304688,-0.828125 -2.40625,-0.828125 H 3.5625 Z m 0,0"
+           id="path4194" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4208"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(422.39211,371.84414)"
+       id="g4206">
+      <g
+         id="g4204">
+        <path
+           d="m 0.546875,-11 h 1.65625 l 2.75,9.5625 h 0.71875 L 8.453125,-11 H 10.09375 L 5.515625,4.890625 H 3.875 L 5.296875,0 h -1.625 z m 0,0"
+           id="path4202" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4216"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(433.01622,371.84414)"
+       id="g4214">
+      <g
+         id="g4212">
+        <path
+           d="m 7.28125,-9.5625 h -3.5 v 5.25 c 0,1.261719 0.085938,2.089844 0.265625,2.484375 0.1875,0.398437 0.628906,0.59375 1.328125,0.59375 l 1.953125,-0.125 L 7.4375,0 c -0.980469,0.15625 -1.730469,0.234375 -2.25,0.234375 -1.148438,0 -1.9375,-0.2734375 -2.375,-0.828125 -0.4375,-0.5625 -0.65625,-1.625 -0.65625,-3.1875 V -9.5625 H 0.59375 V -11 h 1.5625 v -3.359375 h 1.625 V -11 h 3.5 z m 0,0"
+           id="path4210" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4224"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(440.73684,371.84414)"
+       id="g4222">
+      <g
+         id="g4220">
+        <path
+           d="m 3.234375,0 h -1.65625 v -15.796875 h 1.65625 v 5.40625 c 1.175781,-0.550781 2.304687,-0.828125 3.390625,-0.828125 1.46875,0 2.453125,0.398438 2.953125,1.1875 0.507813,0.792969 0.765625,2.199219 0.765625,4.21875 V 0 H 8.6875 v -5.765625 c 0,-1.519531 -0.152344,-2.5625 -0.453125,-3.125 C 7.929688,-9.460938 7.300781,-9.75 6.34375,-9.75 c -0.929688,0 -1.824219,0.171875 -2.6875,0.515625 L 3.234375,-9.09375 Z m 0,0"
+           id="path4218" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4232"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(452.54873,371.84414)"
+       id="g4230">
+      <g
+         id="g4228">
+        <path
+           d="m 1.09375,-5.515625 c 0,-2.007813 0.359375,-3.460937 1.078125,-4.359375 0.71875,-0.894531 1.929687,-1.34375 3.640625,-1.34375 1.707031,0 2.914062,0.449219 3.625,1.34375 0.71875,0.898438 1.078125,2.351562 1.078125,4.359375 0,2 -0.339844,3.460937 -1.015625,4.375 -0.679688,0.90625 -1.914062,1.359375 -3.703125,1.359375 -1.78125,0 -3.011719,-0.453125 -3.6875,-1.359375 -0.679687,-0.914063 -1.015625,-2.375 -1.015625,-4.375 z m 1.703125,-0.03125 c 0,1.605469 0.191406,2.730469 0.578125,3.375 0.382812,0.648437 1.195312,0.96875 2.4375,0.96875 1.238281,0 2.050781,-0.316406 2.4375,-0.953125 0.382812,-0.644531 0.578125,-1.773438 0.578125,-3.390625 0,-1.613281 -0.214844,-2.722656 -0.640625,-3.328125 -0.429688,-0.613281 -1.21875,-0.921875 -2.375,-0.921875 -1.148438,0 -1.9375,0.308594 -2.375,0.921875 -0.429688,0.605469 -0.640625,1.714844 -0.640625,3.328125 z m 0,0"
+           id="path4226" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4240"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(464.16266,371.84414)"
+       id="g4238">
+      <g
+         id="g4236">
+        <path
+           d="M 3.234375,0 H 1.578125 V -11 H 3.21875 v 0.765625 c 1.1875,-0.65625 2.320312,-0.984375 3.40625,-0.984375 1.46875,0 2.453125,0.398438 2.953125,1.1875 0.507813,0.792969 0.765625,2.199219 0.765625,4.21875 V 0 h -1.625 v -5.765625 c 0,-1.519531 -0.152344,-2.5625 -0.453125,-3.125 C 7.960938,-9.460938 7.320312,-9.75 6.34375,-9.75 c -0.480469,0 -0.980469,0.074219 -1.5,0.21875 -0.523438,0.136719 -0.917969,0.273438 -1.1875,0.40625 l -0.421875,0.1875 z m 0,0"
+           id="path4234" />
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#3cea3902db)"
+     id="g4244"
+     transform="translate(-69.242111,-250.64609)">
+    <path
+       fill="#ffffff"
+       d="m 400.46484,364.71094 -7.35156,-5.36328 c -0.11328,-0.082 -0.25,-0.0899 -0.375,-0.0274 -0.0586,0.0312 -0.1875,0.125 -0.1875,0.32031 v 2.9375 c 0,0.17969 -0.14453,0.32813 -0.32031,0.32813 h -9.28516 c -0.17578,0 -0.32031,0.14844 -0.32031,0.33203 v 3.29688 c 0,0.18359 0.14453,0.33203 0.32031,0.33203 h 9.28516 c 0.17578,0 0.32031,0.14843 0.32031,0.32812 v 2.9375 c 0,0.19531 0.12891,0.28906 0.1875,0.32031 0.125,0.0664 0.26172,0.0547 0.375,-0.0273 l 7.35156,-5.36328 c 0.0781,-0.0586 0.0859,-0.14063 0.0859,-0.17578 0,-0.0352 -0.008,-0.11719 -0.0859,-0.17578"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4242" />
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4252"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(358.72771,337.8254)"
+       id="g4250">
+      <g
+         id="g4248">
+        <path
+           d="m 6.796875,0.234375 c -2.199219,0 -3.695313,-0.601563 -4.484375,-1.8125 -0.78125,-1.21875 -1.171875,-3.21875 -1.171875,-6 0,-2.789063 0.394531,-4.773437 1.1875,-5.953125 0.789063,-1.1875 2.28125,-1.78125 4.46875,-1.78125 1.300781,0 2.738281,0.183594 4.3125,0.546875 l -0.09375,1.984375 c -1.3125,-0.238281 -2.632813,-0.359375 -3.953125,-0.359375 -1.324219,0 -2.21875,0.398437 -2.6875,1.1875 -0.46875,0.78125 -0.703125,2.257813 -0.703125,4.421875 0,2.15625 0.222656,3.632812 0.671875,4.421875 0.457031,0.78125 1.347656,1.171875 2.671875,1.171875 1.320313,0 2.65625,-0.109375 4,-0.328125 l 0.07813,2.03125 c -1.511719,0.3125 -2.945312,0.46875 -4.296875,0.46875 z m 0,0"
+           id="path4246" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4260"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(370.69358,337.8254)"
+       id="g4258">
+      <g
+         id="g4256">
+        <path
+           d="m 2.046875,-9.796875 c 0.757813,-0.957031 2.019531,-1.4375 3.78125,-1.4375 1.757813,0 3.015625,0.480469 3.765625,1.4375 0.757812,0.949219 1.140625,2.375 1.140625,4.28125 0,1.90625 -0.371094,3.34375 -1.109375,4.3125 -0.730469,0.960937 -1.996094,1.4375 -3.796875,1.4375 -1.804687,0 -3.074219,-0.476563 -3.8125,-1.4375 -0.730469,-0.96875 -1.09375,-2.40625 -1.09375,-4.3125 0,-1.90625 0.375,-3.332031 1.125,-4.28125 z M 3.84375,-2.65625 c 0.34375,0.585938 1.003906,0.875 1.984375,0.875 0.976563,0 1.632813,-0.289062 1.96875,-0.875 C 8.140625,-3.25 8.3125,-4.210938 8.3125,-5.546875 c 0,-1.332031 -0.183594,-2.273437 -0.546875,-2.828125 -0.355469,-0.5625 -1,-0.84375 -1.9375,-0.84375 -0.9375,0 -1.589844,0.28125 -1.953125,0.84375 -0.355469,0.554688 -0.53125,1.496094 -0.53125,2.828125 0,1.335937 0.164062,2.296875 0.5,2.890625 z m 0,0"
+           id="path4254" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4268"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(382.3515,337.8254)"
+       id="g4266">
+      <g
+         id="g4264">
+        <path
+           d="M 3.84375,0 H 1.453125 v -11 h 2.375 v 0.6875 c 1.070313,-0.613281 2.082031,-0.921875 3.03125,-0.921875 1.46875,0 2.46875,0.417969 3,1.25 0.539063,0.824219 0.8125,2.1875 0.8125,4.09375 V 0 h -2.375 v -5.828125 c 0,-1.1875 -0.132813,-2.03125 -0.390625,-2.53125 -0.25,-0.5 -0.773438,-0.75 -1.5625,-0.75 -0.75,0 -1.46875,0.148437 -2.15625,0.4375 L 3.84375,-8.53125 Z m 0,0"
+           id="path4262" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4276"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(394.36136,337.8254)"
+       id="g4274">
+      <g
+         id="g4272">
+        <path
+           d="m 0.421875,-11 h 2.5 L 5.03125,-2.046875 H 5.734375 L 7.9375,-11 h 2.453125 L 7.53125,0 H 3.25 Z m 0,0"
+           id="path4270" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4284"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(405.16143,337.8254)"
+       id="g4282">
+      <g
+         id="g4280">
+        <path
+           d="m 9.28125,-1.984375 0.625,-0.0625 0.03125,1.78125 c -1.667969,0.3320312 -3.148438,0.5 -4.4375,0.5 -1.625,0 -2.796875,-0.441406 -3.515625,-1.328125 -0.710937,-0.894531 -1.0625,-2.328125 -1.0625,-4.296875 0,-3.894531 1.59375,-5.84375 4.78125,-5.84375 3.070313,0 4.609375,1.679687 4.609375,5.03125 l -0.15625,1.71875 h -6.8125 c 0.00781,0.90625 0.207031,1.574219 0.59375,2 0.382812,0.429687 1.097656,0.640625 2.140625,0.640625 1.039063,0 2.109375,-0.046875 3.203125,-0.140625 z M 7.96875,-6.34375 c 0,-1.082031 -0.171875,-1.835938 -0.515625,-2.265625 -0.34375,-0.4375 -0.929687,-0.65625 -1.75,-0.65625 -0.824219,0 -1.421875,0.230469 -1.796875,0.6875 -0.375,0.460937 -0.570312,1.203125 -0.578125,2.234375 z m 0,0"
+           id="path4278" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4292"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(416.33545,337.8254)"
+       id="g4290">
+      <g
+         id="g4288">
+        <path
+           d="m 1.453125,0 v -11 h 2.375 v 1.3125 c 1.25,-0.800781 2.492187,-1.316406 3.734375,-1.546875 v 2.390625 c -1.261719,0.25 -2.339844,0.574219 -3.234375,0.96875 L 3.84375,-7.671875 V 0 Z m 0,0"
+           id="path4286" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4300"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(424.27603,337.8254)"
+       id="g4298">
+      <g
+         id="g4296">
+        <path
+           d="M 7.375,-8.953125 H 4.328125 v 4.84375 c 0,0.898437 0.066406,1.492187 0.203125,1.78125 0.132812,0.292969 0.472656,0.4375 1.015625,0.4375 l 1.796875,-0.0625 0.109375,1.90625 c -0.980469,0.1875 -1.726563,0.28125 -2.234375,0.28125 -1.25,0 -2.109375,-0.28125 -2.578125,-0.84375 -0.460937,-0.570313 -0.6875,-1.648437 -0.6875,-3.234375 V -8.953125 H 0.546875 V -11 h 1.40625 v -3.1875 h 2.375 V -11 H 7.375 Z m 0,0"
+           id="path4294" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4308"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(432.15063,337.8254)"
+       id="g4306">
+      <g
+         id="g4304">
+        <path
+           d="m 9.28125,-1.984375 0.625,-0.0625 0.03125,1.78125 c -1.667969,0.3320312 -3.148438,0.5 -4.4375,0.5 -1.625,0 -2.796875,-0.441406 -3.515625,-1.328125 -0.710937,-0.894531 -1.0625,-2.328125 -1.0625,-4.296875 0,-3.894531 1.59375,-5.84375 4.78125,-5.84375 3.070313,0 4.609375,1.679687 4.609375,5.03125 l -0.15625,1.71875 h -6.8125 c 0.00781,0.90625 0.207031,1.574219 0.59375,2 0.382812,0.429687 1.097656,0.640625 2.140625,0.640625 1.039063,0 2.109375,-0.046875 3.203125,-0.140625 z M 7.96875,-6.34375 c 0,-1.082031 -0.171875,-1.835938 -0.515625,-2.265625 -0.34375,-0.4375 -0.929687,-0.65625 -1.75,-0.65625 -0.824219,0 -1.421875,0.230469 -1.796875,0.6875 -0.375,0.460937 -0.570312,1.203125 -0.578125,2.234375 z m 0,0"
+           id="path4302" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4316"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(443.32464,337.8254)"
+       id="g4314">
+      <g
+         id="g4312">
+        <path
+           d="m 1.453125,0 v -11 h 2.375 v 1.3125 c 1.25,-0.800781 2.492187,-1.316406 3.734375,-1.546875 v 2.390625 c -1.261719,0.25 -2.339844,0.574219 -3.234375,0.96875 L 3.84375,-7.671875 V 0 Z m 0,0"
+           id="path4310" />
+      </g>
+    </g>
+  </g>
+  <path
+     fill="#41cb51"
+     d="m 256.85164,314.90078 v -77.19921 c 0,-0.9336 0.0898,-1.85938 0.27344,-2.77344 0.17968,-0.91406 0.44922,-1.80469 0.80468,-2.66406 0.35547,-0.86329 0.79297,-1.6836 1.3086,-2.45704 0.51562,-0.77734 1.10547,-1.49218 1.76172,-2.15234 0.65625,-0.66016 1.37109,-1.25 2.14453,-1.76953 0.77344,-0.51563 1.58984,-0.95313 2.44922,-1.3125 0.85937,-0.35547 1.74218,-0.625 2.65625,-0.80859 0.91015,-0.17969 1.83203,-0.27344 2.76172,-0.27344 h 129.44531 c 0.92969,0 1.85156,0.0937 2.76172,0.27344 0.91406,0.18359 1.79687,0.45312 2.65625,0.80859 0.85937,0.35937 1.67578,0.79687 2.44922,1.3125 0.77343,0.51953 1.48828,1.10937 2.14453,1.76953 0.66015,0.66016 1.24609,1.375 1.76172,2.15234 0.51562,0.77344 0.95312,1.59375 1.30859,2.45704 0.35547,0.85937 0.625,1.75 0.80469,2.66406 0.18359,0.91406 0.27343,1.83984 0.27343,2.77344 v 77.19921 c 0,0.9336 -0.0898,1.85938 -0.27343,2.77344 -0.17969,0.91406 -0.44922,1.80078 -0.80469,2.66406 -0.35547,0.86329 -0.79297,1.67969 -1.30859,2.45704 -0.51563,0.77343 -1.10157,1.49218 -1.76172,2.15234 -0.65625,0.66016 -1.3711,1.25 -2.14453,1.76562 -0.77344,0.51954 -1.58985,0.95704 -2.44922,1.3125 -0.85938,0.35938 -1.74219,0.62891 -2.65625,0.8086 -0.91016,0.18359 -1.83203,0.27344 -2.76172,0.27344 H 271.0118 c -0.92969,0 -1.85157,-0.0899 -2.76172,-0.27344 -0.91407,-0.17969 -1.79688,-0.44922 -2.65625,-0.8086 -0.85938,-0.35546 -1.67578,-0.79296 -2.44922,-1.3125 -0.77344,-0.51562 -1.48828,-1.10546 -2.14453,-1.76562 -0.65625,-0.66016 -1.2461,-1.37891 -1.76172,-2.15234 -0.51563,-0.77735 -0.95313,-1.59375 -1.3086,-2.45704 -0.35546,-0.86328 -0.625,-1.75 -0.80468,-2.66406 -0.1836,-0.91406 -0.27344,-1.83984 -0.27344,-2.77344 z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path4318" />
+  <g
+     clip-path="url(#dfab995897)"
+     id="g4322"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:#17a81a;fill-opacity:1;stroke:none;stroke-width:0.82824755;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 127,132.95834 0.0687,26.45833 h 63.43127 l 5.29167,-5.29167 v -26.45833 h -63.5 z"
-       id="path3715-5-6-7-9-8-7"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="ccccccc" />
+       fill="#41cb51"
+       d="m 484.67187,488.34766 v 77.19531 c 0,0.98828 -0.0937,1.96484 -0.28515,2.93359 -0.19531,0.96875 -0.47656,1.90625 -0.85547,2.82031 -0.375,0.91016 -0.83594,1.77735 -1.38281,2.59766 -0.54688,0.82031 -1.16797,1.57813 -1.86328,2.27734 -0.69532,0.69532 -1.44922,1.32032 -2.26954,1.86719 -0.8164,0.54688 -1.67968,1.01172 -2.58984,1.39063 -0.90625,0.375 -1.84375,0.66015 -2.80859,0.85156 -0.96485,0.19531 -1.9375,0.28906 -2.92188,0.28906 h -129.4375 c -0.98437,0 -1.95703,-0.0937 -2.92187,-0.28906 -0.96485,-0.19141 -1.90235,-0.47656 -2.8086,-0.85156 -0.91015,-0.37891 -1.77343,-0.84375 -2.58984,-1.39063 -0.82031,-0.54687 -1.57422,-1.17187 -2.26953,-1.86719 -0.69531,-0.69921 -1.31641,-1.45703 -1.86328,-2.27734 -0.54688,-0.82031 -1.00782,-1.6875 -1.38282,-2.59766 -0.3789,-0.91406 -0.66015,-1.85156 -0.85546,-2.82031 -0.19141,-0.96875 -0.28516,-1.94531 -0.28516,-2.93359 v -77.19531 c 0,-0.98829 0.0937,-1.96485 0.28516,-2.9336 0.19531,-0.96875 0.47656,-1.90625 0.85546,-2.82031 0.375,-0.91016 0.83594,-1.77734 1.38282,-2.59766 0.54687,-0.82031 1.16797,-1.57812 1.86328,-2.27734 0.69531,-0.69531 1.44922,-1.32031 2.26953,-1.86719 0.81641,-0.54687 1.67969,-1.01172 2.58984,-1.39062 0.90625,-0.375 1.84375,-0.66016 2.8086,-0.85547 0.96484,-0.19141 1.9375,-0.28516 2.92187,-0.28516 h 129.44141 c 0.98437,0 1.95703,0.0937 2.92187,0.28906 0.96485,0.19141 1.90235,0.47657 2.8086,0.85547 0.91015,0.375 1.76953,0.83985 2.58984,1.38672 0.81641,0.55078 1.57422,1.17188 2.26953,1.8711 0.69531,0.69531 1.3125,1.45703 1.85938,2.27734 0.54687,0.82031 1.00781,1.68359 1.38281,2.59766 0.37891,0.91015 0.66406,1.84765 0.85547,2.8164 0.1914,0.96875 0.28515,1.94531 0.28515,2.9336 z m -157.76171,77.19531 c 0,0.88281 0.082,1.7539 0.2539,2.61328 0.17188,0.86328 0.42578,1.70312 0.76172,2.51562 0.33594,0.8125 0.74609,1.58204 1.23047,2.3125 0.48828,0.73438 1.04297,1.41016 1.66016,2.03125 0.62109,0.6211 1.29687,1.17579 2.02343,1.66407 0.73047,0.48828 1.5,0.90234 2.3086,1.23828 0.80859,0.33594 1.64453,0.58984 2.5039,0.76172 0.85938,0.17187 1.72657,0.25781 2.60547,0.25781 h 129.44141 c 0.875,0 1.74609,-0.0859 2.60547,-0.25781 0.85937,-0.17188 1.69531,-0.42578 2.5039,-0.76172 0.8086,-0.33594 1.57813,-0.75 2.3086,-1.23828 0.72656,-0.48828 1.40234,-1.04297 2.01953,-1.66407 0.62109,-0.62109 1.17578,-1.29687 1.66015,-2.03125 0.48829,-0.73046 0.89844,-1.5 1.23438,-2.3125 0.33594,-0.8125 0.58984,-1.65234 0.76172,-2.51562 0.16797,-0.85938 0.2539,-1.73047 0.2539,-2.61328 v -77.19531 c 0,-0.88282 -0.0859,-1.75391 -0.2539,-2.61329 -0.17188,-0.86328 -0.42578,-1.70312 -0.76172,-2.51562 -0.33594,-0.8125 -0.74609,-1.58203 -1.23438,-2.3125 -0.48437,-0.73438 -1.03906,-1.41016 -1.66015,-2.03125 -0.61719,-0.62109 -1.29297,-1.17578 -2.01953,-1.66406 -0.73047,-0.48828 -1.5,-0.90235 -2.3086,-1.23828 -0.80859,-0.33594 -1.64453,-0.58985 -2.5039,-0.76172 -0.85938,-0.17188 -1.73047,-0.25782 -2.60547,-0.25782 H 340.25781 c -0.8789,0 -1.74609,0.0859 -2.60547,0.25782 -0.85937,0.17187 -1.69531,0.42578 -2.5039,0.76172 -0.8086,0.33593 -1.57813,0.75 -2.3086,1.23828 -0.72656,0.48828 -1.40234,1.04297 -2.02343,1.66406 -0.61719,0.62109 -1.17188,1.29687 -1.66016,2.03125 -0.48438,0.73047 -0.89453,1.5 -1.23047,2.3125 -0.33594,0.8125 -0.58984,1.65234 -0.76172,2.51562 -0.17187,0.85938 -0.2539,1.73047 -0.2539,2.61329 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4320" />
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4330"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(336.46249,547.41743)"
+       id="g4328">
+      <g
+         id="g4326">
+        <path
+           d="M 7.4375,-5.125 H 3.5625 V 0 H 1.875 v -15.21875 h 5.5625 c 1.65625,0 2.878906,0.40625 3.671875,1.21875 0.789063,0.804688 1.1875,2.03125 1.1875,3.6875 0,3.460938 -1.621094,5.1875 -4.859375,5.1875 z m -3.875,-1.5 h 3.84375 c 2.101562,0 3.15625,-1.226562 3.15625,-3.6875 0,-1.175781 -0.25,-2.039062 -0.75,-2.59375 -0.5,-0.550781 -1.304688,-0.828125 -2.40625,-0.828125 H 3.5625 Z m 0,0"
+           id="path4324" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4338"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(349.50617,547.41743)"
+       id="g4336">
+      <g
+         id="g4334">
+        <path
+           d="m 0.546875,-11 h 1.65625 l 2.75,9.5625 h 0.71875 L 8.453125,-11 H 10.09375 L 5.515625,4.890625 H 3.875 L 5.296875,0 h -1.625 z m 0,0"
+           id="path4332" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4346"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(360.13028,547.41743)"
+       id="g4344">
+      <g
+         id="g4342">
+        <path
+           d="m 7.28125,-9.5625 h -3.5 v 5.25 c 0,1.261719 0.085938,2.089844 0.265625,2.484375 0.1875,0.398437 0.628906,0.59375 1.328125,0.59375 l 1.953125,-0.125 L 7.4375,0 c -0.980469,0.15625 -1.730469,0.234375 -2.25,0.234375 -1.148438,0 -1.9375,-0.2734375 -2.375,-0.828125 -0.4375,-0.5625 -0.65625,-1.625 -0.65625,-3.1875 V -9.5625 H 0.59375 V -11 h 1.5625 v -3.359375 h 1.625 V -11 h 3.5 z m 0,0"
+           id="path4340" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4354"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(367.8509,547.41743)"
+       id="g4352">
+      <g
+         id="g4350">
+        <path
+           d="m 3.234375,0 h -1.65625 v -15.796875 h 1.65625 v 5.40625 c 1.175781,-0.550781 2.304687,-0.828125 3.390625,-0.828125 1.46875,0 2.453125,0.398438 2.953125,1.1875 0.507813,0.792969 0.765625,2.199219 0.765625,4.21875 V 0 H 8.6875 v -5.765625 c 0,-1.519531 -0.152344,-2.5625 -0.453125,-3.125 C 7.929688,-9.460938 7.300781,-9.75 6.34375,-9.75 c -0.929688,0 -1.824219,0.171875 -2.6875,0.515625 L 3.234375,-9.09375 Z m 0,0"
+           id="path4348" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4362"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(379.6628,547.41743)"
+       id="g4360">
+      <g
+         id="g4358">
+        <path
+           d="m 1.09375,-5.515625 c 0,-2.007813 0.359375,-3.460937 1.078125,-4.359375 0.71875,-0.894531 1.929687,-1.34375 3.640625,-1.34375 1.707031,0 2.914062,0.449219 3.625,1.34375 0.71875,0.898438 1.078125,2.351562 1.078125,4.359375 0,2 -0.339844,3.460937 -1.015625,4.375 -0.679688,0.90625 -1.914062,1.359375 -3.703125,1.359375 -1.78125,0 -3.011719,-0.453125 -3.6875,-1.359375 -0.679687,-0.914063 -1.015625,-2.375 -1.015625,-4.375 z m 1.703125,-0.03125 c 0,1.605469 0.191406,2.730469 0.578125,3.375 0.382812,0.648437 1.195312,0.96875 2.4375,0.96875 1.238281,0 2.050781,-0.316406 2.4375,-0.953125 0.382812,-0.644531 0.578125,-1.773438 0.578125,-3.390625 0,-1.613281 -0.214844,-2.722656 -0.640625,-3.328125 -0.429688,-0.613281 -1.21875,-0.921875 -2.375,-0.921875 -1.148438,0 -1.9375,0.308594 -2.375,0.921875 -0.429688,0.605469 -0.640625,1.714844 -0.640625,3.328125 z m 0,0"
+           id="path4356" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4370"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(391.27673,547.41743)"
+       id="g4368">
+      <g
+         id="g4366">
+        <path
+           d="M 3.234375,0 H 1.578125 V -11 H 3.21875 v 0.765625 c 1.1875,-0.65625 2.320312,-0.984375 3.40625,-0.984375 1.46875,0 2.453125,0.398438 2.953125,1.1875 0.507813,0.792969 0.765625,2.199219 0.765625,4.21875 V 0 h -1.625 v -5.765625 c 0,-1.519531 -0.152344,-2.5625 -0.453125,-3.125 C 7.960938,-9.460938 7.320312,-9.75 6.34375,-9.75 c -0.480469,0 -0.980469,0.074219 -1.5,0.21875 -0.523438,0.136719 -0.917969,0.273438 -1.1875,0.40625 l -0.421875,0.1875 z m 0,0"
+           id="path4364" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4376"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(403.08359,547.41743)"
+       id="g4374">
+      <g
+         id="g4372" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4382"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(407.92272,547.41743)"
+       id="g4380">
+      <g
+         id="g4378" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4388"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(412.76185,547.41743)"
+       id="g4386">
+      <g
+         id="g4384" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4394"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(417.60099,547.41743)"
+       id="g4392">
+      <g
+         id="g4390" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4400"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(422.44012,547.41743)"
+       id="g4398">
+      <g
+         id="g4396" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4406"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(427.27926,547.41743)"
+       id="g4404">
+      <g
+         id="g4402" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4412"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(432.11839,547.41743)"
+       id="g4410">
+      <g
+         id="g4408" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4420"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(436.95077,547.41743)"
+       id="g4418">
+      <g
+         id="g4416">
+        <path
+           d="M 11.0625,-0.234375 C 9.550781,0.0664062 8.191406,0.21875 6.984375,0.21875 5.785156,0.21875 4.816406,0.0546875 4.078125,-0.265625 3.335938,-0.597656 2.765625,-1.113281 2.359375,-1.8125 1.960938,-2.507812 1.6875,-3.304688 1.53125,-4.203125 c -0.15625,-0.90625 -0.234375,-2.03125 -0.234375,-3.375 0,-1.351563 0.078125,-2.488281 0.234375,-3.40625 0.15625,-0.914063 0.429688,-1.722656 0.828125,-2.421875 0.40625,-0.707031 0.972656,-1.222656 1.703125,-1.546875 0.738281,-0.320313 1.691406,-0.484375 2.859375,-0.484375 1.175781,0 2.554687,0.164062 4.140625,0.484375 L 11,-13.53125 c -1.480469,-0.257812 -2.796875,-0.390625 -3.953125,-0.390625 -1.617187,0 -2.683594,0.480469 -3.203125,1.4375 -0.523438,0.960937 -0.78125,2.601563 -0.78125,4.921875 0,1.15625 0.046875,2.089844 0.140625,2.796875 0.09375,0.699219 0.28125,1.328125 0.5625,1.890625 0.28125,0.5625 0.6875,0.96875 1.21875,1.21875 0.53125,0.242188 1.3125,0.359375 2.34375,0.359375 1.039063,0 2.265625,-0.128906 3.671875,-0.390625 z m 0,0"
+           id="path4414" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4428"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(448.91665,547.41743)"
+       id="g4426">
+      <g
+         id="g4424">
+        <path
+           d="M 1.203125,-4.78125 V -6.265625 H 5.375 V -10.5625 h 1.53125 v 4.296875 h 4.203125 V -4.78125 H 6.90625 V -0.4375 H 5.375 v -4.34375 z m 0,0"
+           id="path4422" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4436"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(461.23445,547.41743)"
+       id="g4434">
+      <g
+         id="g4432">
+        <path
+           d="M 1.203125,-4.78125 V -6.265625 H 5.375 V -10.5625 h 1.53125 v 4.296875 h 4.203125 V -4.78125 H 6.90625 V -0.4375 H 5.375 v -4.34375 z m 0,0"
+           id="path4430" />
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#2d1327caba)"
+     id="g4440"
+     transform="translate(-69.242111,-250.64609)">
+    <path
+       fill="#ffffff"
+       d="m 429.78516,540.28516 -7.35157,-5.36329 c -0.10937,-0.082 -0.25,-0.0937 -0.375,-0.0273 -0.0547,0.0312 -0.1875,0.125 -0.1875,0.32031 v 2.9375 c 0,0.17969 -0.14453,0.32813 -0.32031,0.32813 h -9.28516 c -0.17578,0 -0.32031,0.14844 -0.32031,0.32812 v 3.30078 c 0,0.1836 0.14453,0.33204 0.32031,0.33204 h 9.28516 c 0.17578,0 0.32031,0.14453 0.32031,0.32812 v 2.9375 c 0,0.19531 0.13282,0.28906 0.1875,0.32031 0.125,0.0625 0.26563,0.0547 0.375,-0.0273 l 7.35157,-5.36328 c 0.0781,-0.0586 0.0898,-0.14453 0.0898,-0.17578 0,-0.0352 -0.0117,-0.11719 -0.0898,-0.17578"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4438" />
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4448"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(358.72771,513.39871)"
+       id="g4446">
+      <g
+         id="g4444">
+        <path
+           d="m 6.796875,0.234375 c -2.199219,0 -3.695313,-0.601563 -4.484375,-1.8125 -0.78125,-1.21875 -1.171875,-3.21875 -1.171875,-6 0,-2.789063 0.394531,-4.773437 1.1875,-5.953125 0.789063,-1.1875 2.28125,-1.78125 4.46875,-1.78125 1.300781,0 2.738281,0.183594 4.3125,0.546875 l -0.09375,1.984375 c -1.3125,-0.238281 -2.632813,-0.359375 -3.953125,-0.359375 -1.324219,0 -2.21875,0.398437 -2.6875,1.1875 -0.46875,0.78125 -0.703125,2.257813 -0.703125,4.421875 0,2.15625 0.222656,3.632812 0.671875,4.421875 0.457031,0.78125 1.347656,1.171875 2.671875,1.171875 1.320313,0 2.65625,-0.109375 4,-0.328125 l 0.07813,2.03125 c -1.511719,0.3125 -2.945312,0.46875 -4.296875,0.46875 z m 0,0"
+           id="path4442" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4456"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(370.69358,513.39871)"
+       id="g4454">
+      <g
+         id="g4452">
+        <path
+           d="m 2.046875,-9.796875 c 0.757813,-0.957031 2.019531,-1.4375 3.78125,-1.4375 1.757813,0 3.015625,0.480469 3.765625,1.4375 0.757812,0.949219 1.140625,2.375 1.140625,4.28125 0,1.90625 -0.371094,3.34375 -1.109375,4.3125 -0.730469,0.960937 -1.996094,1.4375 -3.796875,1.4375 -1.804687,0 -3.074219,-0.476563 -3.8125,-1.4375 -0.730469,-0.96875 -1.09375,-2.40625 -1.09375,-4.3125 0,-1.90625 0.375,-3.332031 1.125,-4.28125 z M 3.84375,-2.65625 c 0.34375,0.585938 1.003906,0.875 1.984375,0.875 0.976563,0 1.632813,-0.289062 1.96875,-0.875 C 8.140625,-3.25 8.3125,-4.210938 8.3125,-5.546875 c 0,-1.332031 -0.183594,-2.273437 -0.546875,-2.828125 -0.355469,-0.5625 -1,-0.84375 -1.9375,-0.84375 -0.9375,0 -1.589844,0.28125 -1.953125,0.84375 -0.355469,0.554688 -0.53125,1.496094 -0.53125,2.828125 0,1.335937 0.164062,2.296875 0.5,2.890625 z m 0,0"
+           id="path4450" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4464"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(382.3515,513.39871)"
+       id="g4462">
+      <g
+         id="g4460">
+        <path
+           d="M 3.84375,0 H 1.453125 v -11 h 2.375 v 0.6875 c 1.070313,-0.613281 2.082031,-0.921875 3.03125,-0.921875 1.46875,0 2.46875,0.417969 3,1.25 0.539063,0.824219 0.8125,2.1875 0.8125,4.09375 V 0 h -2.375 v -5.828125 c 0,-1.1875 -0.132813,-2.03125 -0.390625,-2.53125 -0.25,-0.5 -0.773438,-0.75 -1.5625,-0.75 -0.75,0 -1.46875,0.148437 -2.15625,0.4375 L 3.84375,-8.53125 Z m 0,0"
+           id="path4458" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4472"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(394.36136,513.39871)"
+       id="g4470">
+      <g
+         id="g4468">
+        <path
+           d="m 0.421875,-11 h 2.5 L 5.03125,-2.046875 H 5.734375 L 7.9375,-11 h 2.453125 L 7.53125,0 H 3.25 Z m 0,0"
+           id="path4466" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4480"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(405.16143,513.39871)"
+       id="g4478">
+      <g
+         id="g4476">
+        <path
+           d="m 9.28125,-1.984375 0.625,-0.0625 0.03125,1.78125 c -1.667969,0.3320312 -3.148438,0.5 -4.4375,0.5 -1.625,0 -2.796875,-0.441406 -3.515625,-1.328125 -0.710937,-0.894531 -1.0625,-2.328125 -1.0625,-4.296875 0,-3.894531 1.59375,-5.84375 4.78125,-5.84375 3.070313,0 4.609375,1.679687 4.609375,5.03125 l -0.15625,1.71875 h -6.8125 c 0.00781,0.90625 0.207031,1.574219 0.59375,2 0.382812,0.429687 1.097656,0.640625 2.140625,0.640625 1.039063,0 2.109375,-0.046875 3.203125,-0.140625 z M 7.96875,-6.34375 c 0,-1.082031 -0.171875,-1.835938 -0.515625,-2.265625 -0.34375,-0.4375 -0.929687,-0.65625 -1.75,-0.65625 -0.824219,0 -1.421875,0.230469 -1.796875,0.6875 -0.375,0.460937 -0.570312,1.203125 -0.578125,2.234375 z m 0,0"
+           id="path4474" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4488"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(416.33545,513.39871)"
+       id="g4486">
+      <g
+         id="g4484">
+        <path
+           d="m 1.453125,0 v -11 h 2.375 v 1.3125 c 1.25,-0.800781 2.492187,-1.316406 3.734375,-1.546875 v 2.390625 c -1.261719,0.25 -2.339844,0.574219 -3.234375,0.96875 L 3.84375,-7.671875 V 0 Z m 0,0"
+           id="path4482" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4496"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(424.27603,513.39871)"
+       id="g4494">
+      <g
+         id="g4492">
+        <path
+           d="M 7.375,-8.953125 H 4.328125 v 4.84375 c 0,0.898437 0.066406,1.492187 0.203125,1.78125 0.132812,0.292969 0.472656,0.4375 1.015625,0.4375 l 1.796875,-0.0625 0.109375,1.90625 c -0.980469,0.1875 -1.726563,0.28125 -2.234375,0.28125 -1.25,0 -2.109375,-0.28125 -2.578125,-0.84375 -0.460937,-0.570313 -0.6875,-1.648437 -0.6875,-3.234375 V -8.953125 H 0.546875 V -11 h 1.40625 v -3.1875 h 2.375 V -11 H 7.375 Z m 0,0"
+           id="path4490" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4504"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(432.15063,513.39871)"
+       id="g4502">
+      <g
+         id="g4500">
+        <path
+           d="m 9.28125,-1.984375 0.625,-0.0625 0.03125,1.78125 c -1.667969,0.3320312 -3.148438,0.5 -4.4375,0.5 -1.625,0 -2.796875,-0.441406 -3.515625,-1.328125 -0.710937,-0.894531 -1.0625,-2.328125 -1.0625,-4.296875 0,-3.894531 1.59375,-5.84375 4.78125,-5.84375 3.070313,0 4.609375,1.679687 4.609375,5.03125 l -0.15625,1.71875 h -6.8125 c 0.00781,0.90625 0.207031,1.574219 0.59375,2 0.382812,0.429687 1.097656,0.640625 2.140625,0.640625 1.039063,0 2.109375,-0.046875 3.203125,-0.140625 z M 7.96875,-6.34375 c 0,-1.082031 -0.171875,-1.835938 -0.515625,-2.265625 -0.34375,-0.4375 -0.929687,-0.65625 -1.75,-0.65625 -0.824219,0 -1.421875,0.230469 -1.796875,0.6875 -0.375,0.460937 -0.570312,1.203125 -0.578125,2.234375 z m 0,0"
+           id="path4498" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4512"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(443.32464,513.39871)"
+       id="g4510">
+      <g
+         id="g4508">
+        <path
+           d="m 1.453125,0 v -11 h 2.375 v 1.3125 c 1.25,-0.800781 2.492187,-1.316406 3.734375,-1.546875 v 2.390625 c -1.261719,0.25 -2.339844,0.574219 -3.234375,0.96875 L 3.84375,-7.671875 V 0 Z m 0,0"
+           id="path4506" />
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#f03e985e13)"
+     id="g4516"
+     transform="translate(-69.242111,-250.64609)">
+    <path
+       fill="#09102b"
+       d="m 113.46875,378.90234 v -55.07031 c 0,-0.66406 0.0625,-1.32422 0.19141,-1.97656 0.13281,-0.65235 0.32422,-1.28516 0.57812,-1.89844 0.25391,-0.61719 0.5625,-1.19922 0.9336,-1.75391 0.36718,-0.55468 0.78515,-1.0664 1.2539,-1.53515 0.46875,-0.46875 0.98047,-0.89063 1.53125,-1.26172 0.55469,-0.36719 1.13672,-0.67969 1.75,-0.93359 0.60938,-0.25782 1.24219,-0.44922 1.89453,-0.57813 0.64844,-0.12891 1.3086,-0.19531 1.96875,-0.19531 h 92.375 c 0.66016,0 1.32031,0.0664 1.96875,0.19531 0.65235,0.12891 1.28516,0.32031 1.89453,0.57813 0.61328,0.2539 1.19532,0.5664 1.75,0.93359 0.55078,0.37109 1.0625,0.79297 1.53125,1.26172 0.46875,0.46875 0.88672,0.98047 1.25391,1.53515 0.37109,0.55469 0.67969,1.13672 0.93359,1.75391 0.25391,0.61328 0.44532,1.24609 0.57813,1.89844 0.1289,0.65234 0.1914,1.3125 0.1914,1.97656 v 55.07031 c 0,0.66407 -0.0625,1.32422 -0.1914,1.97657 -0.13281,0.65234 -0.32422,1.28515 -0.57813,1.89843 -0.2539,0.61719 -0.5625,1.19922 -0.93359,1.75391 -0.36719,0.55469 -0.78516,1.06641 -1.25391,1.53516 -0.46875,0.46875 -0.98047,0.89062 -1.53125,1.26171 -0.55468,0.36719 -1.13672,0.67969 -1.75,0.9336 -0.60937,0.25781 -1.24218,0.44922 -1.89453,0.57812 -0.64844,0.12891 -1.30859,0.19532 -1.96875,0.19532 h -92.375 c -0.66015,0 -1.32031,-0.0664 -1.96875,-0.19532 -0.65234,-0.1289 -1.28515,-0.32031 -1.89453,-0.57812 -0.61328,-0.25391 -1.19531,-0.56641 -1.75,-0.9336 -0.55078,-0.37109 -1.0625,-0.79296 -1.53125,-1.26171 -0.46875,-0.46875 -0.88672,-0.98047 -1.2539,-1.53516 -0.3711,-0.55469 -0.67969,-1.13672 -0.9336,-1.75391 -0.2539,-0.61328 -0.44531,-1.24609 -0.57812,-1.89843 -0.12891,-0.65235 -0.19141,-1.3125 -0.19141,-1.97657 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4514" />
+  </g>
+  <g
+     clip-path="url(#c71ef1b2fa)"
+     id="g4520"
+     transform="translate(-69.242111,-250.64609)">
+    <path
+       fill="#09102b"
+       d="m 226.62891,323.83203 v 55.06641 c 0,0.70312 -0.0703,1.40234 -0.20704,2.08984 -0.13671,0.69141 -0.33984,1.36328 -0.60546,2.01172 -0.26954,0.65234 -0.59766,1.26953 -0.98829,1.85156 -0.39062,0.58594 -0.83203,1.12891 -1.32812,1.625 -0.49609,0.5 -1.03906,0.94141 -1.62109,1.33594 -0.58204,0.39062 -1.19922,0.71875 -1.84766,0.98828 -0.64844,0.26953 -1.31641,0.47266 -2.00391,0.60938 -0.6875,0.13671 -1.38281,0.20703 -2.08593,0.20703 h -92.36719 c -0.70313,0 -1.39844,-0.0703 -2.08594,-0.20703 -0.6875,-0.13672 -1.35547,-0.33985 -2.0039,-0.60938 -0.64844,-0.26953 -1.26563,-0.59766 -1.84766,-0.98828 -0.58203,-0.39453 -1.125,-0.83594 -1.62109,-1.33594 -0.4961,-0.49609 -0.9375,-1.03906 -1.32813,-1.625 -0.39062,-0.58203 -0.71875,-1.19922 -0.98828,-1.85156 -0.26563,-0.64844 -0.46875,-1.32031 -0.60547,-2.01172 -0.13672,-0.6875 -0.20703,-1.38672 -0.20703,-2.08984 v -55.06641 c 0,-0.70312 0.0703,-1.39844 0.20703,-2.08984 0.13672,-0.69141 0.33984,-1.35938 0.60547,-2.01172 0.26953,-0.64844 0.59766,-1.26563 0.98828,-1.85156 0.39063,-0.58594 0.83203,-1.125 1.32813,-1.625 0.49609,-0.4961 1.03906,-0.94141 1.62109,-1.33204 0.58203,-0.39062 1.19922,-0.72265 1.84766,-0.99218 0.64843,-0.26953 1.3164,-0.47266 2.0039,-0.60938 0.6875,-0.13672 1.38281,-0.20703 2.08594,-0.20703 h 92.37109 c 0.69922,0 1.39453,0.0703 2.08203,0.20703 0.6875,0.13672 1.35547,0.33985 2.00391,0.60938 0.64844,0.26953 1.26562,0.60156 1.84766,0.99218 0.58593,0.39063 1.125,0.83594 1.62109,1.33204 0.49609,0.5 0.9375,1.03906 1.32812,1.625 0.39063,0.58593 0.71875,1.20312 0.98829,1.85156 0.26562,0.65234 0.46875,1.32031 0.60546,2.01172 0.13672,0.6914 0.20704,1.38672 0.20704,2.08984 z m -112.58203,55.06641 c 0,0.6289 0.0625,1.25 0.18359,1.86328 0.125,0.61719 0.30469,1.21484 0.54297,1.79297 0.23828,0.57812 0.53125,1.1289 0.8789,1.65234 0.34766,0.51953 0.74219,1.00391 1.1875,1.44531 0.44141,0.44532 0.92188,0.83985 1.44141,1.19141 0.51953,0.34766 1.07031,0.64062 1.64844,0.88281 0.57812,0.23828 1.17187,0.41797 1.78515,0.54297 0.61329,0.12109 1.23438,0.18359 1.85938,0.18359 h 92.37109 c 0.625,0 1.24219,-0.0625 1.85547,-0.18359 0.61328,-0.125 1.21094,-0.30469 1.78906,-0.54297 0.57813,-0.24219 1.125,-0.53515 1.64453,-0.88281 0.52344,-0.35156 1.00391,-0.74609 1.44532,-1.19141 0.4414,-0.4414 0.83593,-0.92578 1.18359,-1.44531 0.34766,-0.52344 0.64063,-1.07422 0.88281,-1.65234 0.23828,-0.57813 0.41797,-1.17578 0.53907,-1.79297 0.125,-0.61328 0.18359,-1.23438 0.18359,-1.86328 v -55.06641 c 0,-0.625 -0.0586,-1.24609 -0.18359,-1.86328 -0.1211,-0.61328 -0.30079,-1.21094 -0.53907,-1.79297 -0.24218,-0.57812 -0.53515,-1.12891 -0.88281,-1.64844 -0.34766,-0.52343 -0.74219,-1.0039 -1.18359,-1.44922 -0.44141,-0.44531 -0.92188,-0.83984 -1.44532,-1.1875 -0.51953,-0.34765 -1.0664,-0.64453 -1.64453,-0.88281 -0.57812,-0.24219 -1.17578,-0.42187 -1.78906,-0.54297 -0.61328,-0.125 -1.23047,-0.18359 -1.85547,-0.18359 h -92.37109 c -0.625,0 -1.24609,0.0586 -1.85938,0.18359 -0.61328,0.1211 -1.20703,0.30078 -1.78515,0.54297 -0.57813,0.23828 -1.12891,0.53516 -1.64844,0.88281 -0.51953,0.34766 -1,0.74219 -1.44141,1.1875 -0.44531,0.44532 -0.83984,0.92579 -1.1875,1.44922 -0.34765,0.51953 -0.64062,1.07032 -0.8789,1.64844 -0.23828,0.58203 -0.41797,1.17969 -0.54297,1.79297 -0.12109,0.61719 -0.18359,1.23828 -0.18359,1.86328 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4518" />
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4528"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(126.50046,359.41913)"
+       id="g4526">
+      <g
+         id="g4524">
+        <path
+           d="M 11.0625,-0.234375 C 9.550781,0.0664062 8.191406,0.21875 6.984375,0.21875 5.785156,0.21875 4.816406,0.0546875 4.078125,-0.265625 3.335938,-0.597656 2.765625,-1.113281 2.359375,-1.8125 1.960938,-2.507812 1.6875,-3.304688 1.53125,-4.203125 c -0.15625,-0.90625 -0.234375,-2.03125 -0.234375,-3.375 0,-1.351563 0.078125,-2.488281 0.234375,-3.40625 0.15625,-0.914063 0.429688,-1.722656 0.828125,-2.421875 0.40625,-0.707031 0.972656,-1.222656 1.703125,-1.546875 0.738281,-0.320313 1.691406,-0.484375 2.859375,-0.484375 1.175781,0 2.554687,0.164062 4.140625,0.484375 L 11,-13.53125 c -1.480469,-0.257812 -2.796875,-0.390625 -3.953125,-0.390625 -1.617187,0 -2.683594,0.480469 -3.203125,1.4375 -0.523438,0.960937 -0.78125,2.601563 -0.78125,4.921875 0,1.15625 0.046875,2.089844 0.140625,2.796875 0.09375,0.699219 0.28125,1.328125 0.5625,1.890625 0.28125,0.5625 0.6875,0.96875 1.21875,1.21875 0.53125,0.242188 1.3125,0.359375 2.34375,0.359375 1.039063,0 2.265625,-0.128906 3.671875,-0.390625 z m 0,0"
+           id="path4522" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4536"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(138.46633,359.41913)"
+       id="g4534">
+      <g
+         id="g4532">
+        <path
+           d="M 1.203125,-4.78125 V -6.265625 H 5.375 V -10.5625 h 1.53125 v 4.296875 h 4.203125 V -4.78125 H 6.90625 V -0.4375 H 5.375 v -4.34375 z m 0,0"
+           id="path4530" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4544"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(150.78413,359.41913)"
+       id="g4542">
+      <g
+         id="g4540">
+        <path
+           d="M 1.203125,-4.78125 V -6.265625 H 5.375 V -10.5625 h 1.53125 v 4.296875 h 4.203125 V -4.78125 H 6.90625 V -0.4375 H 5.375 v -4.34375 z m 0,0"
+           id="path4538" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4550"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(163.10194,359.41913)"
+       id="g4548">
+      <g
+         id="g4546" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4558"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(167.94108,359.41913)"
+       id="g4556">
+      <g
+         id="g4554">
+        <path
+           d="m 0.28125,-13.703125 v -1.515625 h 11 v 1.515625 H 6.640625 V 0 H 4.96875 v -13.703125 z m 0,0"
+           id="path4552" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4566"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(179.51102,359.41913)"
+       id="g4564">
+      <g
+         id="g4562">
+        <path
+           d="m 0.546875,-11 h 1.65625 l 2.75,9.5625 h 0.71875 L 8.453125,-11 H 10.09375 L 5.515625,4.890625 H 3.875 L 5.296875,0 h -1.625 z m 0,0"
+           id="path4560" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4574"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(190.13512,359.41913)"
+       id="g4572">
+      <g
+         id="g4570">
+        <path
+           d="M 1.578125,4.890625 V -11 H 3.21875 v 0.796875 c 1.113281,-0.675781 2.210938,-1.015625 3.296875,-1.015625 1.394531,0 2.40625,0.445312 3.03125,1.328125 C 10.179688,-9.003906 10.5,-7.539062 10.5,-5.5 c 0,2.042969 -0.375,3.507812 -1.125,4.390625 -0.742188,0.886719 -1.964844,1.328125 -3.671875,1.328125 -0.898437,0 -1.71875,-0.078125 -2.46875,-0.234375 v 4.90625 z M 6.265625,-9.75 c -0.4375,0 -0.914063,0.074219 -1.421875,0.21875 -0.5,0.148438 -0.898438,0.292969 -1.1875,0.4375 l -0.421875,0.234375 v 7.40625 c 1.039063,0.167969 1.832031,0.25 2.375,0.25 1.1875,0 2.019531,-0.335937 2.5,-1.015625 0.476563,-0.675781 0.71875,-1.773438 0.71875,-3.296875 0,-1.53125 -0.21875,-2.617187 -0.65625,-3.265625 C 7.742188,-9.425781 7.109375,-9.75 6.265625,-9.75 Z m 0,0"
+           id="path4568" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4582"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(201.72705,359.41913)"
+       id="g4580">
+      <g
+         id="g4578">
+        <path
+           d="M 9.0625,-1.359375 9.703125,-1.4375 9.75,-0.125 C 8.070312,0.101562 6.640625,0.21875 5.453125,0.21875 c -1.585937,0 -2.710937,-0.457031 -3.375,-1.375 C 1.421875,-2.070312 1.09375,-3.5 1.09375,-5.4375 c 0,-3.851562 1.535156,-5.78125 4.609375,-5.78125 1.476563,0 2.582031,0.417969 3.3125,1.25 0.738281,0.824219 1.109375,2.121094 1.109375,3.890625 L 10.03125,-4.8125 H 2.765625 c 0,1.21875 0.21875,2.121094 0.65625,2.703125 0.445313,0.585937 1.21875,0.875 2.3125,0.875 1.09375,0 2.203125,-0.039063 3.328125,-0.125 z m -0.59375,-4.78125 c 0,-1.34375 -0.21875,-2.289063 -0.65625,-2.84375 -0.429688,-0.5625 -1.132812,-0.84375 -2.109375,-0.84375 -0.96875,0 -1.703125,0.292969 -2.203125,0.875 -0.492188,0.585937 -0.742188,1.523437 -0.75,2.8125 z m 0,0"
+           id="path4576" />
+      </g>
+    </g>
+  </g>
+  <path
+     fill="#09102b"
+     d="m 524.81258,303.82657 v -55.06641 c 0,-0.66406 0.0664,-1.32422 0.19531,-1.97656 0.12891,-0.65235 0.32031,-1.28516 0.57422,-1.90235 0.2539,-0.61328 0.5664,-1.19531 0.93359,-1.75 0.3711,-0.55468 0.78906,-1.0664 1.25781,-1.53515 0.46875,-0.47266 0.98047,-0.89063 1.53125,-1.26172 0.55079,-0.3711 1.13282,-0.67969 1.7461,-0.9375 0.61328,-0.25391 1.24609,-0.44531 1.89453,-0.57422 0.65234,-0.12891 1.30859,-0.19531 1.97266,-0.19531 h 92.37109 c 0.66406,0 1.32031,0.0664 1.97266,0.19531 0.64843,0.12891 1.28125,0.32031 1.89453,0.57422 0.61328,0.25781 1.19531,0.5664 1.74609,0.9375 0.55469,0.37109 1.0625,0.78906 1.53125,1.26172 0.46875,0.46875 0.89063,0.98047 1.25781,1.53515 0.36719,0.55469 0.67969,1.13672 0.9336,1.75 0.2539,0.61719 0.44531,1.25 0.57422,1.90235 0.1289,0.65234 0.19531,1.3125 0.19531,1.97656 v 55.06641 c 0,0.66796 -0.0664,1.32421 -0.19531,1.97656 -0.12891,0.65625 -0.32032,1.28906 -0.57422,1.90234 -0.25391,0.61328 -0.56641,1.19922 -0.9336,1.75391 -0.36718,0.55078 -0.78906,1.0625 -1.25781,1.53515 -0.46875,0.46875 -0.97656,0.89063 -1.53125,1.25782 -0.55078,0.37109 -1.13281,0.68359 -1.74609,0.9375 -0.61328,0.2539 -1.2461,0.44922 -1.89453,0.57812 -0.65235,0.12891 -1.3086,0.19531 -1.97266,0.19531 h -92.37109 c -0.66407,0 -1.32032,-0.0664 -1.97266,-0.19531 -0.64844,-0.1289 -1.28125,-0.32422 -1.89453,-0.57812 -0.61328,-0.25391 -1.19531,-0.56641 -1.7461,-0.9375 -0.55078,-0.36719 -1.0625,-0.78907 -1.53125,-1.25782 -0.46875,-0.47265 -0.88671,-0.98437 -1.25781,-1.53515 -0.36719,-0.55469 -0.67969,-1.14063 -0.93359,-1.75391 -0.25391,-0.61328 -0.44531,-1.24609 -0.57422,-1.90234 -0.12891,-0.65235 -0.19531,-1.3086 -0.19531,-1.97656 z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path4584" />
+  <g
+     clip-path="url(#3bddcdf684)"
+     id="g4588"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:#3a4055;fill-opacity:1;stroke:none;stroke-width:0.67261654;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 68.791667,132.95834 v 26.45833 H 105.83333 L 111.125,154.125 V 127.66667 H 74.083333 Z"
-       id="path3715-5-6-7-9-8-7-6-3"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="ccccccc" />
+       fill="#09102b"
+       d="m 707.21875,499.40625 v 55.06641 c 0,0.70312 -0.0703,1.39843 -0.20703,2.08984 -0.13672,0.69141 -0.33985,1.35937 -0.60938,2.01172 -0.26562,0.64844 -0.59765,1.26562 -0.98828,1.85156 -0.38672,0.58594 -0.83203,1.12891 -1.32812,1.625 -0.4961,0.49609 -1.03516,0.94141 -1.61719,1.33203 -0.58594,0.39063 -1.19922,0.72266 -1.84766,0.99219 -0.64843,0.26953 -1.3164,0.47266 -2.00781,0.60937 -0.6875,0.13672 -1.38281,0.20704 -2.08203,0.20704 h -92.36719 c -0.70312,0 -1.39844,-0.0703 -2.08594,-0.20704 -0.6875,-0.13671 -1.35546,-0.33984 -2.0039,-0.60937 -0.64844,-0.26953 -1.26563,-0.60156 -1.84766,-0.99219 -0.58594,-0.39062 -1.125,-0.83594 -1.62109,-1.33203 -0.4961,-0.49609 -0.9375,-1.03906 -1.32813,-1.625 -0.39062,-0.58594 -0.71875,-1.20312 -0.98828,-1.85156 -0.26953,-0.65235 -0.47265,-1.32031 -0.60937,-2.01172 -0.13672,-0.69141 -0.20313,-1.38672 -0.20313,-2.08984 v -55.06641 c 0,-0.70313 0.0664,-1.39844 0.20313,-2.08984 0.13672,-0.69141 0.33984,-1.35938 0.60937,-2.01172 0.26953,-0.64844 0.59766,-1.26953 0.98828,-1.85157 0.39063,-0.58593 0.83203,-1.1289 1.32813,-1.625 0.49609,-0.5 1.03515,-0.9414 1.62109,-1.33203 0.58203,-0.39062 1.19922,-0.72265 1.84766,-0.99218 0.64844,-0.26954 1.3164,-0.47266 2.0039,-0.60938 0.6875,-0.13672 1.38282,-0.20703 2.08594,-0.20703 h 92.36719 c 0.70312,0 1.39844,0.0703 2.08594,0.20703 0.6875,0.13672 1.35547,0.33984 2.0039,0.60938 0.64844,0.26953 1.26563,0.60156 1.84766,0.99218 0.58203,0.39063 1.12109,0.83594 1.61719,1.33203 0.49609,0.4961 0.9414,1.03907 1.33203,1.625 0.38672,0.58594 0.71875,1.20313 0.98437,1.85157 0.26953,0.65234 0.47266,1.32031 0.60938,2.01172 0.13672,0.6914 0.20703,1.38671 0.20703,2.08984 z m -112.58203,55.06641 c 0,0.625 0.0625,1.24609 0.18359,1.86328 0.1211,0.61328 0.30078,1.21093 0.54297,1.79297 0.23828,0.57812 0.53125,1.1289 0.87891,1.65234 0.34765,0.51953 0.74218,1.00391 1.18359,1.44531 0.44531,0.44531 0.92578,0.83985 1.44531,1.1875 0.51953,0.35156 1.06641,0.64453 1.64453,0.88281 0.57813,0.24219 1.17579,0.42188 1.78907,0.54297 0.61328,0.125 1.23047,0.1836 1.85937,0.1836 h 92.36719 c 0.625,0 1.24609,-0.0586 1.85937,-0.1836 0.61329,-0.12109 1.20704,-0.30078 1.78516,-0.54297 0.57813,-0.23828 1.12891,-0.53125 1.64844,-0.88281 0.51953,-0.34765 1,-0.74219 1.44531,-1.1875 0.44141,-0.4414 0.83594,-0.92578 1.18359,-1.44531 0.34766,-0.52344 0.64063,-1.07422 0.87891,-1.65234 0.23828,-0.58204 0.42188,-1.17969 0.54297,-1.79297 0.12109,-0.61719 0.18359,-1.23828 0.18359,-1.86328 v -55.06641 c 0,-0.625 -0.0625,-1.24609 -0.18359,-1.86328 -0.12109,-0.61328 -0.30469,-1.21094 -0.54297,-1.79297 -0.23828,-0.57813 -0.53125,-1.12891 -0.87891,-1.65234 -0.34765,-0.51954 -0.74218,-1.00391 -1.18359,-1.44532 -0.44531,-0.44531 -0.92578,-0.83984 -1.44531,-1.1875 -0.51953,-0.35156 -1.07031,-0.64453 -1.64844,-0.88281 -0.57812,-0.24219 -1.17187,-0.42187 -1.78516,-0.54687 -0.61328,-0.1211 -1.23437,-0.1836 -1.85937,-0.1836 h -92.36719 c -0.6289,0 -1.24609,0.0625 -1.85937,0.1836 -0.61328,0.125 -1.21094,0.30468 -1.78907,0.54687 -0.57812,0.23828 -1.125,0.53125 -1.64453,0.88281 -0.51953,0.34766 -1,0.74219 -1.44531,1.1875 -0.44141,0.44141 -0.83594,0.92578 -1.18359,1.44532 -0.34766,0.52343 -0.64063,1.07421 -0.87891,1.65234 -0.24219,0.58203 -0.42187,1.17969 -0.54297,1.79297 -0.12109,0.61719 -0.18359,1.23828 -0.18359,1.86328 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4586" />
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4596"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(607.08883,534.99247)"
+       id="g4594">
+      <g
+         id="g4592">
+        <path
+           d="M 11.0625,-0.234375 C 9.550781,0.0664062 8.191406,0.21875 6.984375,0.21875 5.785156,0.21875 4.816406,0.0546875 4.078125,-0.265625 3.335938,-0.597656 2.765625,-1.113281 2.359375,-1.8125 1.960938,-2.507812 1.6875,-3.304688 1.53125,-4.203125 c -0.15625,-0.90625 -0.234375,-2.03125 -0.234375,-3.375 0,-1.351563 0.078125,-2.488281 0.234375,-3.40625 0.15625,-0.914063 0.429688,-1.722656 0.828125,-2.421875 0.40625,-0.707031 0.972656,-1.222656 1.703125,-1.546875 0.738281,-0.320313 1.691406,-0.484375 2.859375,-0.484375 1.175781,0 2.554687,0.164062 4.140625,0.484375 L 11,-13.53125 c -1.480469,-0.257812 -2.796875,-0.390625 -3.953125,-0.390625 -1.617187,0 -2.683594,0.480469 -3.203125,1.4375 -0.523438,0.960937 -0.78125,2.601563 -0.78125,4.921875 0,1.15625 0.046875,2.089844 0.140625,2.796875 0.09375,0.699219 0.28125,1.328125 0.5625,1.890625 0.28125,0.5625 0.6875,0.96875 1.21875,1.21875 0.53125,0.242188 1.3125,0.359375 2.34375,0.359375 1.039063,0 2.265625,-0.128906 3.671875,-0.390625 z m 0,0"
+           id="path4590" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4604"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(619.0547,534.99247)"
+       id="g4602">
+      <g
+         id="g4600">
+        <path
+           d="M 1.203125,-4.78125 V -6.265625 H 5.375 V -10.5625 h 1.53125 v 4.296875 h 4.203125 V -4.78125 H 6.90625 V -0.4375 H 5.375 v -4.34375 z m 0,0"
+           id="path4598" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4612"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(631.37251,534.99247)"
+       id="g4610">
+      <g
+         id="g4608">
+        <path
+           d="M 1.203125,-4.78125 V -6.265625 H 5.375 V -10.5625 h 1.53125 v 4.296875 h 4.203125 V -4.78125 H 6.90625 V -0.4375 H 5.375 v -4.34375 z m 0,0"
+           id="path4606" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4618"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(643.69031,534.99247)"
+       id="g4616">
+      <g
+         id="g4614" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4626"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(648.52945,534.99247)"
+       id="g4624">
+      <g
+         id="g4622">
+        <path
+           d="m 0.28125,-13.703125 v -1.515625 h 11 v 1.515625 H 6.640625 V 0 H 4.96875 v -13.703125 z m 0,0"
+           id="path4620" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4634"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(660.09939,534.99247)"
+       id="g4632">
+      <g
+         id="g4630">
+        <path
+           d="m 0.546875,-11 h 1.65625 l 2.75,9.5625 h 0.71875 L 8.453125,-11 H 10.09375 L 5.515625,4.890625 H 3.875 L 5.296875,0 h -1.625 z m 0,0"
+           id="path4628" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4642"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(670.72349,534.99247)"
+       id="g4640">
+      <g
+         id="g4638">
+        <path
+           d="M 1.578125,4.890625 V -11 H 3.21875 v 0.796875 c 1.113281,-0.675781 2.210938,-1.015625 3.296875,-1.015625 1.394531,0 2.40625,0.445312 3.03125,1.328125 C 10.179688,-9.003906 10.5,-7.539062 10.5,-5.5 c 0,2.042969 -0.375,3.507812 -1.125,4.390625 -0.742188,0.886719 -1.964844,1.328125 -3.671875,1.328125 -0.898437,0 -1.71875,-0.078125 -2.46875,-0.234375 v 4.90625 z M 6.265625,-9.75 c -0.4375,0 -0.914063,0.074219 -1.421875,0.21875 -0.5,0.148438 -0.898438,0.292969 -1.1875,0.4375 l -0.421875,0.234375 v 7.40625 c 1.039063,0.167969 1.832031,0.25 2.375,0.25 1.1875,0 2.019531,-0.335937 2.5,-1.015625 0.476563,-0.675781 0.71875,-1.773438 0.71875,-3.296875 0,-1.53125 -0.21875,-2.617187 -0.65625,-3.265625 C 7.742188,-9.425781 7.109375,-9.75 6.265625,-9.75 Z m 0,0"
+           id="path4636" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4650"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(682.31543,534.99247)"
+       id="g4648">
+      <g
+         id="g4646">
+        <path
+           d="M 9.0625,-1.359375 9.703125,-1.4375 9.75,-0.125 C 8.070312,0.101562 6.640625,0.21875 5.453125,0.21875 c -1.585937,0 -2.710937,-0.457031 -3.375,-1.375 C 1.421875,-2.070312 1.09375,-3.5 1.09375,-5.4375 c 0,-3.851562 1.535156,-5.78125 4.609375,-5.78125 1.476563,0 2.582031,0.417969 3.3125,1.25 0.738281,0.824219 1.109375,2.121094 1.109375,3.890625 L 10.03125,-4.8125 H 2.765625 c 0,1.21875 0.21875,2.121094 0.65625,2.703125 0.445313,0.585937 1.21875,0.875 2.3125,0.875 1.09375,0 2.203125,-0.039063 3.328125,-0.125 z m -0.59375,-4.78125 c 0,-1.34375 -0.21875,-2.289063 -0.65625,-2.84375 -0.429688,-0.5625 -1.132812,-0.84375 -2.109375,-0.84375 -0.96875,0 -1.703125,0.292969 -2.203125,0.875 -0.492188,0.585937 -0.742188,1.523437 -0.75,2.8125 z m 0,0"
+           id="path4644" />
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#cd19a8dfa8)"
+     id="g4656"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:#848895;fill-opacity:1;stroke:none;stroke-width:0.52087492;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="M 58.208333,173.96875 V 185.875 h 48.947917 l 3.96875,-3.96875 V 170 H 62.177083 Z"
-       id="path3715-5-6-7-9-8-7-6-56"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="ccccccc" />
+       fill="#306998"
+       d="m 588.69141,378.90234 v -55.07031 c 0,-0.66406 0.0664,-1.32422 0.19531,-1.97656 0.1289,-0.65235 0.32031,-1.28516 0.57422,-1.89844 0.2539,-0.61719 0.5664,-1.19922 0.93359,-1.75391 0.37109,-0.55468 0.78906,-1.0664 1.25781,-1.53515 0.46875,-0.46875 0.98047,-0.89063 1.53125,-1.26172 0.55078,-0.36719 1.13282,-0.67969 1.7461,-0.93359 0.61328,-0.25782 1.24609,-0.44922 1.89843,-0.57813 0.64844,-0.12891 1.30469,-0.19531 1.96875,-0.19531 h 92.3711 c 0.66406,0 1.32031,0.0664 1.97265,0.19531 0.65235,0.12891 1.28125,0.32031 1.89454,0.57813 0.61328,0.2539 1.19531,0.5664 1.74609,0.93359 0.55469,0.37109 1.0625,0.79297 1.53125,1.26172 0.46875,0.46875 0.89062,0.98047 1.25781,1.53515 0.36719,0.55469 0.67969,1.13672 0.9336,1.75391 0.2539,0.61328 0.44531,1.24609 0.57421,1.89844 0.12891,0.65234 0.19532,1.3125 0.19532,1.97656 v 55.07031 c 0,0.66407 -0.0664,1.32422 -0.19532,1.97657 -0.1289,0.65234 -0.32031,1.28515 -0.57421,1.89843 -0.25391,0.61719 -0.56641,1.19922 -0.9336,1.75391 -0.36719,0.55469 -0.78906,1.06641 -1.25781,1.53516 -0.46875,0.46875 -0.97656,0.89062 -1.53125,1.26171 -0.55078,0.36719 -1.13281,0.67969 -1.74609,0.9336 -0.61329,0.25781 -1.24219,0.44922 -1.89454,0.57812 -0.65234,0.12891 -1.30859,0.19532 -1.97265,0.19532 h -92.3711 c -0.66406,0 -1.32031,-0.0664 -1.96875,-0.19532 -0.65234,-0.1289 -1.28515,-0.32031 -1.89843,-0.57812 -0.61328,-0.25391 -1.19532,-0.56641 -1.7461,-0.9336 -0.55078,-0.37109 -1.0625,-0.79296 -1.53125,-1.26171 -0.46875,-0.46875 -0.88672,-0.98047 -1.25781,-1.53516 -0.36719,-0.55469 -0.67969,-1.13672 -0.93359,-1.75391 -0.25391,-0.61328 -0.44532,-1.24609 -0.57422,-1.89843 -0.12891,-0.65235 -0.19531,-1.3125 -0.19531,-1.97657 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4652" />
     <path
-       style="fill:#17a81a;fill-opacity:1;stroke:none;stroke-width:0.82824755;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 127.00003,175.29167 0.0687,26.45833 H 190.5 l 5.29167,-5.29167 V 170 h -63.5 z"
-       id="path3715-5-6-7-9-8-7-2"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="ccccccc" />
+       fill="#306998"
+       d="m 701.85547,323.83203 v 55.06641 c 0,0.70312 -0.0703,1.40234 -0.20703,2.08984 -0.13672,0.69141 -0.33985,1.36328 -0.60938,2.01172 -0.26562,0.65234 -0.59765,1.26953 -0.98437,1.85156 -0.39063,0.58594 -0.83594,1.12891 -1.33203,1.625 -0.4961,0.5 -1.03516,0.94141 -1.61719,1.33594 -0.58594,0.39062 -1.19922,0.71875 -1.84766,0.98828 -0.64844,0.26953 -1.3164,0.47266 -2.0039,0.60938 -0.69141,0.13671 -1.38672,0.20703 -2.08594,0.20703 h -92.36719 c -0.70312,0 -1.39844,-0.0703 -2.08594,-0.20703 -0.6875,-0.13672 -1.35547,-0.33985 -2.0039,-0.60938 -0.64844,-0.26953 -1.26563,-0.59766 -1.84766,-0.98828 -0.58594,-0.39453 -1.125,-0.83594 -1.62109,-1.33594 -0.4961,-0.49609 -0.9375,-1.03906 -1.32813,-1.625 -0.39062,-0.58203 -0.71875,-1.19922 -0.98828,-1.85156 -0.26953,-0.64844 -0.47266,-1.32031 -0.60937,-2.01172 -0.13672,-0.6875 -0.20313,-1.38672 -0.20313,-2.08984 v -55.06641 c 0,-0.70312 0.0664,-1.39844 0.20313,-2.08984 0.13671,-0.69141 0.33984,-1.35938 0.60937,-2.01172 0.26953,-0.64844 0.59766,-1.26563 0.98828,-1.85156 0.39063,-0.58594 0.83203,-1.125 1.32813,-1.625 0.49609,-0.4961 1.03515,-0.94141 1.62109,-1.33204 0.58203,-0.39062 1.19922,-0.72265 1.84766,-0.99218 0.64843,-0.26953 1.3164,-0.47266 2.0039,-0.60938 0.6875,-0.13672 1.38282,-0.20703 2.08594,-0.20703 h 92.36719 c 0.70312,0 1.39844,0.0703 2.08594,0.20703 0.6875,0.13672 1.35546,0.33985 2.0039,0.60938 0.64844,0.26953 1.26563,0.60156 1.84766,0.99218 0.58203,0.39063 1.125,0.83594 1.62109,1.33204 0.4961,0.5 0.9375,1.03906 1.32813,1.625 0.39062,0.58593 0.71875,1.20312 0.98437,1.85156 0.26953,0.65234 0.47266,1.32031 0.60938,2.01172 0.13672,0.6914 0.20703,1.38672 0.20703,2.08984 z m -112.58203,55.06641 c 0,0.6289 0.0625,1.25 0.18359,1.86328 0.12109,0.61719 0.30469,1.21484 0.54297,1.79297 0.23828,0.57812 0.53125,1.1289 0.87891,1.65234 0.34765,0.51953 0.74218,1.00391 1.18359,1.44531 0.44531,0.44532 0.92578,0.83985 1.44531,1.19141 0.51953,0.34766 1.07031,0.64062 1.64844,0.88281 0.57422,0.23828 1.17187,0.41797 1.78516,0.54297 0.61328,0.12109 1.23437,0.18359 1.85937,0.18359 h 92.36719 c 0.625,0 1.24609,-0.0625 1.85937,-0.18359 0.61328,-0.125 1.21094,-0.30469 1.78907,-0.54297 0.57421,-0.24219 1.125,-0.53515 1.64453,-0.88281 0.51953,-0.35156 1,-0.74609 1.44531,-1.19141 0.44141,-0.4414 0.83594,-0.92578 1.18359,-1.44531 0.34766,-0.52344 0.64063,-1.07422 0.87891,-1.65234 0.24219,-0.57813 0.42187,-1.17578 0.54297,-1.79297 0.12109,-0.61328 0.18359,-1.23438 0.18359,-1.86328 v -55.06641 c 0,-0.625 -0.0625,-1.24609 -0.18359,-1.86328 -0.1211,-0.61328 -0.30078,-1.21094 -0.54297,-1.79297 -0.23828,-0.57812 -0.53125,-1.12891 -0.87891,-1.64844 -0.34765,-0.52343 -0.74218,-1.0039 -1.18359,-1.44922 -0.44531,-0.44531 -0.92578,-0.83984 -1.44531,-1.1875 -0.51953,-0.34765 -1.07032,-0.64453 -1.64453,-0.88281 -0.57813,-0.24219 -1.17579,-0.42187 -1.78907,-0.54297 -0.61328,-0.125 -1.23437,-0.18359 -1.85937,-0.18359 h -92.36719 c -0.625,0 -1.24609,0.0586 -1.85937,0.18359 -0.61329,0.1211 -1.21094,0.30078 -1.78516,0.54297 -0.57813,0.23828 -1.12891,0.53516 -1.64844,0.88281 -0.51953,0.34766 -1,0.74219 -1.44531,1.1875 -0.44141,0.44532 -0.83594,0.92579 -1.18359,1.44922 -0.34766,0.51953 -0.64063,1.07032 -0.87891,1.64844 -0.23828,0.58203 -0.42188,1.17969 -0.54297,1.79297 -0.12109,0.61719 -0.18359,1.23828 -0.18359,1.86328 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4654" />
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4664"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(611.5815,344.04413)"
+       id="g4662">
+      <g
+         id="g4660">
+        <path
+           d="M 7.4375,-5.125 H 3.5625 V 0 H 1.875 v -15.21875 h 5.5625 c 1.65625,0 2.878906,0.40625 3.671875,1.21875 0.789063,0.804688 1.1875,2.03125 1.1875,3.6875 0,3.460938 -1.621094,5.1875 -4.859375,5.1875 z m -3.875,-1.5 h 3.84375 c 2.101562,0 3.15625,-1.226562 3.15625,-3.6875 0,-1.175781 -0.25,-2.039062 -0.75,-2.59375 -0.5,-0.550781 -1.304688,-0.828125 -2.40625,-0.828125 H 3.5625 Z m 0,0"
+           id="path4658" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4672"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(624.62518,344.04413)"
+       id="g4670">
+      <g
+         id="g4668">
+        <path
+           d="m 0.546875,-11 h 1.65625 l 2.75,9.5625 h 0.71875 L 8.453125,-11 H 10.09375 L 5.515625,4.890625 H 3.875 L 5.296875,0 h -1.625 z m 0,0"
+           id="path4666" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4680"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(635.24928,344.04413)"
+       id="g4678">
+      <g
+         id="g4676">
+        <path
+           d="m 7.28125,-9.5625 h -3.5 v 5.25 c 0,1.261719 0.085938,2.089844 0.265625,2.484375 0.1875,0.398437 0.628906,0.59375 1.328125,0.59375 l 1.953125,-0.125 L 7.4375,0 c -0.980469,0.15625 -1.730469,0.234375 -2.25,0.234375 -1.148438,0 -1.9375,-0.2734375 -2.375,-0.828125 -0.4375,-0.5625 -0.65625,-1.625 -0.65625,-3.1875 V -9.5625 H 0.59375 V -11 h 1.5625 v -3.359375 h 1.625 V -11 h 3.5 z m 0,0"
+           id="path4674" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4688"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(642.96991,344.04413)"
+       id="g4686">
+      <g
+         id="g4684">
+        <path
+           d="m 3.234375,0 h -1.65625 v -15.796875 h 1.65625 v 5.40625 c 1.175781,-0.550781 2.304687,-0.828125 3.390625,-0.828125 1.46875,0 2.453125,0.398438 2.953125,1.1875 0.507813,0.792969 0.765625,2.199219 0.765625,4.21875 V 0 H 8.6875 v -5.765625 c 0,-1.519531 -0.152344,-2.5625 -0.453125,-3.125 C 7.929688,-9.460938 7.300781,-9.75 6.34375,-9.75 c -0.929688,0 -1.824219,0.171875 -2.6875,0.515625 L 3.234375,-9.09375 Z m 0,0"
+           id="path4682" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4696"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(654.7818,344.04413)"
+       id="g4694">
+      <g
+         id="g4692">
+        <path
+           d="m 1.09375,-5.515625 c 0,-2.007813 0.359375,-3.460937 1.078125,-4.359375 0.71875,-0.894531 1.929687,-1.34375 3.640625,-1.34375 1.707031,0 2.914062,0.449219 3.625,1.34375 0.71875,0.898438 1.078125,2.351562 1.078125,4.359375 0,2 -0.339844,3.460937 -1.015625,4.375 -0.679688,0.90625 -1.914062,1.359375 -3.703125,1.359375 -1.78125,0 -3.011719,-0.453125 -3.6875,-1.359375 -0.679687,-0.914063 -1.015625,-2.375 -1.015625,-4.375 z m 1.703125,-0.03125 c 0,1.605469 0.191406,2.730469 0.578125,3.375 0.382812,0.648437 1.195312,0.96875 2.4375,0.96875 1.238281,0 2.050781,-0.316406 2.4375,-0.953125 0.382812,-0.644531 0.578125,-1.773438 0.578125,-3.390625 0,-1.613281 -0.214844,-2.722656 -0.640625,-3.328125 -0.429688,-0.613281 -1.21875,-0.921875 -2.375,-0.921875 -1.148438,0 -1.9375,0.308594 -2.375,0.921875 -0.429688,0.605469 -0.640625,1.714844 -0.640625,3.328125 z m 0,0"
+           id="path4690" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4704"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(666.39573,344.04413)"
+       id="g4702">
+      <g
+         id="g4700">
+        <path
+           d="M 3.234375,0 H 1.578125 V -11 H 3.21875 v 0.765625 c 1.1875,-0.65625 2.320312,-0.984375 3.40625,-0.984375 1.46875,0 2.453125,0.398438 2.953125,1.1875 0.507813,0.792969 0.765625,2.199219 0.765625,4.21875 V 0 h -1.625 v -5.765625 c 0,-1.519531 -0.152344,-2.5625 -0.453125,-3.125 C 7.960938,-9.460938 7.320312,-9.75 6.34375,-9.75 c -0.480469,0 -0.980469,0.074219 -1.5,0.21875 -0.523438,0.136719 -0.917969,0.273438 -1.1875,0.40625 l -0.421875,0.1875 z m 0,0"
+           id="path4698" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4712"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(622.45064,374.79413)"
+       id="g4710">
+      <g
+         id="g4708">
+        <path
+           d="m 0.28125,-13.703125 v -1.515625 h 11 v 1.515625 H 6.640625 V 0 H 4.96875 v -13.703125 z m 0,0"
+           id="path4706" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4720"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(634.02058,374.79413)"
+       id="g4718">
+      <g
+         id="g4716">
+        <path
+           d="m 0.546875,-11 h 1.65625 l 2.75,9.5625 h 0.71875 L 8.453125,-11 H 10.09375 L 5.515625,4.890625 H 3.875 L 5.296875,0 h -1.625 z m 0,0"
+           id="path4714" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4728"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(644.64468,374.79413)"
+       id="g4726">
+      <g
+         id="g4724">
+        <path
+           d="M 1.578125,4.890625 V -11 H 3.21875 v 0.796875 c 1.113281,-0.675781 2.210938,-1.015625 3.296875,-1.015625 1.394531,0 2.40625,0.445312 3.03125,1.328125 C 10.179688,-9.003906 10.5,-7.539062 10.5,-5.5 c 0,2.042969 -0.375,3.507812 -1.125,4.390625 -0.742188,0.886719 -1.964844,1.328125 -3.671875,1.328125 -0.898437,0 -1.71875,-0.078125 -2.46875,-0.234375 v 4.90625 z M 6.265625,-9.75 c -0.4375,0 -0.914063,0.074219 -1.421875,0.21875 -0.5,0.148438 -0.898438,0.292969 -1.1875,0.4375 l -0.421875,0.234375 v 7.40625 c 1.039063,0.167969 1.832031,0.25 2.375,0.25 1.1875,0 2.019531,-0.335937 2.5,-1.015625 0.476563,-0.675781 0.71875,-1.773438 0.71875,-3.296875 0,-1.53125 -0.21875,-2.617187 -0.65625,-3.265625 C 7.742188,-9.425781 7.109375,-9.75 6.265625,-9.75 Z m 0,0"
+           id="path4722" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4736"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(656.23661,374.79413)"
+       id="g4734">
+      <g
+         id="g4732">
+        <path
+           d="M 9.0625,-1.359375 9.703125,-1.4375 9.75,-0.125 C 8.070312,0.101562 6.640625,0.21875 5.453125,0.21875 c -1.585937,0 -2.710937,-0.457031 -3.375,-1.375 C 1.421875,-2.070312 1.09375,-3.5 1.09375,-5.4375 c 0,-3.851562 1.535156,-5.78125 4.609375,-5.78125 1.476563,0 2.582031,0.417969 3.3125,1.25 0.738281,0.824219 1.109375,2.121094 1.109375,3.890625 L 10.03125,-4.8125 H 2.765625 c 0,1.21875 0.21875,2.121094 0.65625,2.703125 0.445313,0.585937 1.21875,0.875 2.3125,0.875 1.09375,0 2.203125,-0.039063 3.328125,-0.125 z m -0.59375,-4.78125 c 0,-1.34375 -0.21875,-2.289063 -0.65625,-2.84375 -0.429688,-0.5625 -1.132812,-0.84375 -2.109375,-0.84375 -0.96875,0 -1.703125,0.292969 -2.203125,0.875 -0.492188,0.585937 -0.742188,1.523437 -0.75,2.8125 z m 0,0"
+           id="path4730" />
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#61b05d6a70)"
+     id="g4740"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:#848895;fill-opacity:1;stroke:none;stroke-width:0.52087492;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 58.208333,195.13542 v 11.90625 h 48.947917 l 3.96875,-3.96875 V 191.16667 H 62.177083 Z"
-       id="path3715-5-6-7-9-8-7-6-56-7"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="ccccccc" />
+       fill="#306998"
+       d="m 125.32813,478.72266 v -43.44532 c 0,-0.52734 0.0508,-1.04687 0.15625,-1.5625 0.10156,-0.51172 0.25,-1.01172 0.45312,-1.49609 0.19922,-0.48828 0.44531,-0.94922 0.73438,-1.38281 0.29296,-0.4375 0.62109,-0.83985 0.99218,-1.21094 0.3711,-0.375 0.77344,-0.70313 1.20703,-0.99609 0.4375,-0.29297 0.89453,-0.53907 1.37891,-0.73829 0.48437,-0.20312 0.98437,-0.35156 1.49609,-0.45703 0.51172,-0.10156 1.03125,-0.15234 1.55469,-0.15234 h 72.875 c 0.52344,0 1.04297,0.0508 1.55859,0.15234 0.51172,0.10547 1.01172,0.25391 1.49219,0.45703 0.48438,0.19922 0.94531,0.44532 1.37891,0.73829 0.4375,0.29296 0.83984,0.62109 1.20703,0.99609 0.37109,0.37109 0.70312,0.77344 0.99219,1.21094 0.29297,0.43359 0.53906,0.89453 0.73828,1.38281 0.19922,0.48437 0.35156,0.98437 0.45312,1.49609 0.10157,0.51563 0.15235,1.03516 0.15235,1.5625 v 43.44532 c 0,0.52343 -0.0508,1.04296 -0.15235,1.55859 -0.10156,0.51562 -0.2539,1.01562 -0.45312,1.5 -0.19922,0.48437 -0.44531,0.94531 -0.73828,1.38281 -0.28907,0.4375 -0.6211,0.83985 -0.99219,1.21094 -0.36719,0.37109 -0.76953,0.70312 -1.20703,0.99219 -0.4336,0.29297 -0.89453,0.53906 -1.37891,0.74218 -0.48047,0.19922 -0.98047,0.35157 -1.49219,0.45313 -0.51562,0.10156 -1.03515,0.15234 -1.55859,0.15234 h -72.875 c -0.52344,0 -1.04297,-0.0508 -1.55469,-0.15234 -0.51172,-0.10156 -1.01172,-0.25391 -1.49609,-0.45313 -0.48438,-0.20312 -0.94141,-0.44921 -1.37891,-0.74218 -0.43359,-0.28907 -0.83593,-0.6211 -1.20703,-0.99219 -0.37109,-0.37109 -0.69922,-0.77344 -0.99218,-1.21094 -0.28907,-0.4375 -0.53516,-0.89844 -0.73438,-1.38281 -0.20312,-0.48438 -0.35156,-0.98438 -0.45312,-1.5 -0.10547,-0.51563 -0.15625,-1.03516 -0.15625,-1.55859 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4738" />
+  </g>
+  <g
+     clip-path="url(#ea42d02648)"
+     id="g4744"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:#848895;fill-opacity:1;stroke:none;stroke-width:0.52087492;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 58.208343,216.30209 v 11.90625 h 48.947907 l 3.96875,-3.96875 V 212.33334 H 62.177093 Z"
-       id="path3715-5-6-7-9-8-7-6-56-0"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="ccccccc" />
-    <text
-       xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:7.05555534px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
-       x="65.68634"
-       y="179.68727"
-       id="text1032"><tspan
-         sodipodi:role="line"
-         id="tspan1030"
-         x="65.68634"
-         y="179.68727"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:7.05555534px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332">PythonType1</tspan></text>
-    <text
-       xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:7.05555534px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
-       x="65.326508"
-       y="200.85394"
-       id="text1032-1"><tspan
-         sodipodi:role="line"
-         id="tspan1030-1"
-         x="65.326508"
-         y="200.85394"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:7.05555534px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332">PythonType2</tspan></text>
-    <text
-       xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:7.05555534px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
-       x="65.319458"
-       y="222.02061"
-       id="text1032-4"><tspan
-         sodipodi:role="line"
-         id="tspan1030-6"
-         x="65.319458"
-         y="222.02061"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:7.05555534px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332">PythonType3</tspan></text>
-    <text
-       xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:Titillium;letter-spacing:0px;word-spacing:0px;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
-       x="90.120621"
-       y="139.29776"
-       id="text1062"><tspan
-         sodipodi:role="line"
-         id="tspan1060"
-         x="90.120621"
-         y="139.29776"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87777805px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332">C++</tspan><tspan
-         sodipodi:role="line"
-         x="90.120621"
-         y="152.52693"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87777805px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332"
-         id="tspan1064">Type</tspan></text>
-    <text
-       xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:Titillium;letter-spacing:0px;word-spacing:0px;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
-       x="135.41069"
-       y="138.95909"
-       id="text1068"><tspan
-         sodipodi:role="line"
-         id="tspan1066"
-         x="135.41069"
-         y="138.95909"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.46666622px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332">Converter</tspan><tspan
-         sodipodi:role="line"
-         x="135.41069"
-         y="152.18826"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.46666622px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332"
-         id="tspan1070">C++ -&gt; Python</tspan></text>
-    <text
-       xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:Titillium;letter-spacing:0px;word-spacing:0px;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
-       x="135.41072"
-       y="181.29242"
-       id="text1068-9"><tspan
-         sodipodi:role="line"
-         id="tspan1066-7"
-         x="135.41072"
-         y="181.29242"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.46666622px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332">Converter</tspan><tspan
-         sodipodi:role="line"
-         x="135.41072"
-         y="194.52159"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.46666622px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332"
-         id="tspan1070-5">Python -&gt; C++</tspan></text>
+       fill="#306998"
+       d="m 214.60547,435.27734 v 43.44141 c 0,0.55469 -0.0508,1.10547 -0.16016,1.65234 -0.10937,0.54297 -0.26953,1.07032 -0.48047,1.58594 -0.21093,0.51172 -0.47265,1 -0.77734,1.46094 -0.30859,0.46094 -0.66016,0.88672 -1.05078,1.28125 -0.39063,0.39453 -0.81641,0.74219 -1.27735,1.05078 -0.46093,0.30859 -0.94531,0.57031 -1.45703,0.78125 -0.51172,0.21484 -1.03906,0.375 -1.58203,0.48047 -0.54297,0.10937 -1.08984,0.16406 -1.64453,0.16406 h -72.87109 c -0.55469,0 -1.10547,-0.0547 -1.64844,-0.16406 -0.54297,-0.10547 -1.07031,-0.26563 -1.57813,-0.48047 -0.51171,-0.21094 -1,-0.47266 -1.46093,-0.78125 -0.46094,-0.30859 -0.88672,-0.65625 -1.27735,-1.05078 -0.39062,-0.39453 -0.73828,-0.82031 -1.04687,-1.28125 -0.30859,-0.46094 -0.56641,-0.94922 -0.78125,-1.46094 -0.21094,-0.51562 -0.37109,-1.04297 -0.47656,-1.58594 -0.10938,-0.54687 -0.16407,-1.09765 -0.16407,-1.65234 v -43.44141 c 0,-0.55468 0.0547,-1.10547 0.16407,-1.65234 0.10547,-0.54297 0.26562,-1.07031 0.47656,-1.58594 0.21484,-0.51172 0.47266,-1 0.78125,-1.46094 0.30859,-0.46093 0.65625,-0.88671 1.04687,-1.28125 0.39063,-0.39453 0.81641,-0.74218 1.27735,-1.05078 0.46093,-0.30859 0.94922,-0.57031 1.46093,-0.78125 0.50782,-0.21484 1.03516,-0.375 1.57813,-0.48047 0.54297,-0.10937 1.09375,-0.16406 1.64844,-0.16406 h 72.87109 c 0.55469,0 1.10156,0.0547 1.64453,0.16406 0.54297,0.10547 1.07031,0.26563 1.58203,0.48047 0.51172,0.21094 1,0.47266 1.45703,0.78125 0.46094,0.3086 0.88672,0.66016 1.27735,1.05078 0.39453,0.39454 0.74219,0.82032 1.05078,1.28125 0.30469,0.46094 0.56641,0.94922 0.77734,1.46094 0.21094,0.51563 0.3711,1.04297 0.48047,1.58985 0.10938,0.54296 0.16016,1.09375 0.16016,1.64843 z m -88.81641,43.44141 c 0,0.49609 0.0469,0.98437 0.14453,1.47266 0.0937,0.48437 0.23829,0.95703 0.42579,1.41406 0.1875,0.45703 0.42187,0.89062 0.69531,1.30078 0.27344,0.41406 0.58594,0.79297 0.93359,1.14453 0.34766,0.34766 0.73047,0.66016 1.14063,0.9375 0.41015,0.27344 0.84375,0.50391 1.29687,0.69531 0.45703,0.1875 0.92578,0.33203 1.41016,0.42969 0.48437,0.0937 0.97265,0.14453 1.46875,0.14453 h 72.87109 c 0.49609,0 0.98438,-0.0508 1.46875,-0.14453 0.48438,-0.0977 0.95313,-0.24219 1.41016,-0.42969 0.45312,-0.1914 0.88672,-0.42187 1.29687,-0.69531 0.41016,-0.27734 0.78906,-0.58984 1.14063,-0.9375 0.34765,-0.35156 0.66015,-0.73047 0.93359,-1.14453 0.27344,-0.41016 0.50781,-0.84375 0.69531,-1.30078 0.1875,-0.45703 0.33203,-0.92969 0.42578,-1.41406 0.0977,-0.48829 0.14454,-0.97657 0.14454,-1.47266 v -43.44141 c 0,-0.49609 -0.0469,-0.98437 -0.14454,-1.47265 -0.0937,-0.48438 -0.23828,-0.95703 -0.42578,-1.41407 -0.1875,-0.45703 -0.42187,-0.89062 -0.69531,-1.30078 -0.27344,-0.41406 -0.58594,-0.79297 -0.93359,-1.14453 -0.35157,-0.34765 -0.73047,-0.66015 -1.14063,-0.9375 -0.41015,-0.27344 -0.84375,-0.5039 -1.29687,-0.69531 -0.45703,-0.1875 -0.92578,-0.33203 -1.41016,-0.42969 -0.48437,-0.0937 -0.97266,-0.14453 -1.46875,-0.14453 h -72.87109 c -0.4961,0 -0.98438,0.0508 -1.46875,0.14453 -0.48438,0.0977 -0.95313,0.24219 -1.41016,0.42969 -0.45312,0.19141 -0.88672,0.42187 -1.29687,0.69531 -0.41016,0.27735 -0.79297,0.58985 -1.14063,0.9375 -0.34765,0.35156 -0.66015,0.73047 -0.93359,1.14453 -0.27344,0.41016 -0.50781,0.84375 -0.69531,1.30078 -0.1875,0.45704 -0.33204,0.92969 -0.42579,1.41407 -0.0977,0.48828 -0.14453,0.97656 -0.14453,1.47265 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4742" />
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4752"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(143.38693,451.22147)"
+       id="g4750">
+      <g
+         id="g4748">
+        <path
+           d="M 5.875,-4.046875 H 2.8125 V 0 H 1.46875 V -12.015625 H 5.875 c 1.300781,0 2.265625,0.320313 2.890625,0.953125 0.625,0.636719 0.9375,1.609375 0.9375,2.921875 0,2.730469 -1.277344,4.09375 -3.828125,4.09375 z M 2.8125,-5.21875 h 3.03125 c 1.65625,0 2.484375,-0.972656 2.484375,-2.921875 0,-0.925781 -0.199219,-1.601563 -0.59375,-2.03125 -0.386719,-0.4375 -1.015625,-0.65625 -1.890625,-0.65625 H 2.8125 Z m 0,0"
+           id="path4746" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4760"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(153.67768,451.22147)"
+       id="g4758">
+      <g
+         id="g4756">
+        <path
+           d="M 0.4375,-8.671875 H 1.734375 L 3.90625,-1.125 h 0.578125 l 2.1875,-7.546875 H 7.96875 L 4.359375,3.859375 H 3.0625 L 4.1875,0 H 2.90625 Z m 0,0"
+           id="path4754" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4768"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(162.05952,451.22147)"
+       id="g4766">
+      <g
+         id="g4764">
+        <path
+           d="M 5.75,-7.546875 H 2.984375 v 4.140625 c 0,1 0.070313,1.65625 0.21875,1.96875 0.144531,0.3125 0.488281,0.46875 1.03125,0.46875 L 5.78125,-1.078125 5.875,0 C 5.09375,0.125 4.5,0.1875 4.09375,0.1875 3.195312,0.1875 2.570312,-0.03125 2.21875,-0.46875 1.875,-0.90625 1.703125,-1.742188 1.703125,-2.984375 v -4.5625 H 0.46875 v -1.125 h 1.234375 v -2.65625 h 1.28125 v 2.65625 H 5.75 Z m 0,0"
+           id="path4762" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4776"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(168.15067,451.22147)"
+       id="g4774">
+      <g
+         id="g4772">
+        <path
+           d="M 2.546875,0 H 1.25 v -12.46875 h 1.296875 v 4.28125 c 0.925781,-0.445312 1.816406,-0.671875 2.671875,-0.671875 1.164062,0 1.945312,0.3125 2.34375,0.9375 0.394531,0.625 0.59375,1.742187 0.59375,3.34375 V 0 H 6.859375 V -4.546875 C 6.859375,-5.753906 6.738281,-6.578125 6.5,-7.015625 6.257812,-7.460938 5.757812,-7.6875 5,-7.6875 c -0.730469,0 -1.4375,0.132812 -2.125,0.390625 l -0.328125,0.125 z m 0,0"
+           id="path4770" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4784"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(177.4696,451.22147)"
+       id="g4782">
+      <g
+         id="g4780">
+        <path
+           d="m 0.875,-4.359375 c 0,-1.582031 0.28125,-2.726563 0.84375,-3.4375 0.5625,-0.707031 1.515625,-1.0625 2.859375,-1.0625 1.351563,0 2.3125,0.355469 2.875,1.0625 0.5625,0.710937 0.84375,1.855469 0.84375,3.4375 C 8.296875,-2.773438 8.03125,-1.625 7.5,-0.90625 6.96875,-0.1875 5.992188,0.171875 4.578125,0.171875 c -1.40625,0 -2.375,-0.359375 -2.90625,-1.078125 C 1.140625,-1.625 0.875,-2.773438 0.875,-4.359375 Z M 2.203125,-4.375 c 0,1.261719 0.148437,2.148438 0.453125,2.65625 0.3125,0.511719 0.957031,0.765625 1.9375,0.765625 0.976562,0 1.617188,-0.25 1.921875,-0.75 C 6.816406,-2.210938 6.96875,-3.101562 6.96875,-4.375 6.96875,-5.644531 6.796875,-6.519531 6.453125,-7 6.117188,-7.476562 5.5,-7.71875 4.59375,-7.71875 3.6875,-7.71875 3.0625,-7.476562 2.71875,-7 2.375,-6.519531 2.203125,-5.644531 2.203125,-4.375 Z m 0,0"
+           id="path4778" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4792"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(186.63236,451.22147)"
+       id="g4790">
+      <g
+         id="g4788">
+        <path
+           d="M 2.546875,0 H 1.25 v -8.671875 h 1.28125 v 0.59375 c 0.9375,-0.519531 1.832031,-0.78125 2.6875,-0.78125 1.164062,0 1.945312,0.3125 2.34375,0.9375 0.394531,0.625 0.59375,1.742187 0.59375,3.34375 V 0 H 6.875 v -4.546875 c 0,-1.207031 -0.121094,-2.03125 -0.359375,-2.46875 C 6.273438,-7.460938 5.769531,-7.6875 5,-7.6875 c -0.375,0 -0.765625,0.058594 -1.171875,0.171875 -0.40625,0.105469 -0.726563,0.210937 -0.953125,0.3125 l -0.328125,0.15625 z m 0,0"
+           id="path4786" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4800"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(145.18979,475.48154)"
+       id="g4798">
+      <g
+         id="g4796">
+        <path
+           d="m 0.21875,-10.8125 v -1.203125 h 8.6875 V -10.8125 H 5.25 V 0 H 3.921875 v -10.8125 z m 0,0"
+           id="path4794" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4808"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(154.31784,475.48154)"
+       id="g4806">
+      <g
+         id="g4804">
+        <path
+           d="M 0.4375,-8.671875 H 1.734375 L 3.90625,-1.125 h 0.578125 l 2.1875,-7.546875 H 7.96875 L 4.359375,3.859375 H 3.0625 L 4.1875,0 H 2.90625 Z m 0,0"
+           id="path4802" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4816"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(162.69968,475.48154)"
+       id="g4814">
+      <g
+         id="g4812">
+        <path
+           d="M 1.25,3.859375 V -8.671875 H 2.53125 V -8.0625 c 0.882812,-0.53125 1.753906,-0.796875 2.609375,-0.796875 1.09375,0 1.890625,0.355469 2.390625,1.0625 0.5,0.699219 0.75,1.855469 0.75,3.46875 0,1.605469 -0.292969,2.757813 -0.875,3.453125 C 6.820312,-0.175781 5.851562,0.171875 4.5,0.171875 c -0.710938,0 -1.359375,-0.0625 -1.953125,-0.1875 v 3.875 z M 4.953125,-7.6875 c -0.355469,0 -0.730469,0.058594 -1.125,0.171875 C 3.429688,-7.398438 3.113281,-7.285156 2.875,-7.171875 L 2.546875,-7 v 5.859375 c 0.820313,0.125 1.445313,0.1875 1.875,0.1875 0.9375,0 1.59375,-0.265625 1.96875,-0.796875 0.382813,-0.53125 0.578125,-1.394531 0.578125,-2.59375 0,-1.207031 -0.171875,-2.066406 -0.515625,-2.578125 -0.34375,-0.507813 -0.84375,-0.765625 -1.5,-0.765625 z m 0,0"
+           id="path4810" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4824"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(171.84508,475.48154)"
+       id="g4822">
+      <g
+         id="g4820">
+        <path
+           d="m 7.15625,-1.078125 0.5,-0.046875 0.03125,1.015625 C 6.375,0.078125 5.25,0.171875 4.3125,0.171875 3.0625,0.171875 2.175781,-0.1875 1.65625,-0.90625 1.132812,-1.632812 0.875,-2.757812 0.875,-4.28125 c 0,-3.050781 1.207031,-4.578125 3.625,-4.578125 1.164062,0 2.035156,0.328125 2.609375,0.984375 0.582031,0.65625 0.875,1.683594 0.875,3.078125 l -0.0625,1 H 2.1875 c 0,0.960937 0.171875,1.671875 0.515625,2.140625 0.351563,0.460938 0.957031,0.6875 1.8125,0.6875 0.863281,0 1.742187,-0.035156 2.640625,-0.109375 z M 6.6875,-4.84375 c 0,-1.0625 -0.171875,-1.8125 -0.515625,-2.25 C 5.828125,-7.539062 5.269531,-7.765625 4.5,-7.765625 c -0.773438,0 -1.351562,0.234375 -1.734375,0.703125 -0.386719,0.460938 -0.585937,1.199219 -0.59375,2.21875 z m 0,0"
+           id="path4818" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4830"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(180.6087,475.48154)"
+       id="g4828">
+      <g
+         id="g4826" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4838"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(184.42651,475.48154)"
+       id="g4836">
+      <g
+         id="g4834">
+        <path
+           d="M 6.75,-11.453125 V 0 H 5.421875 V -9.96875 L 2.46875,-8.015625 1.859375,-9.03125 5.5,-11.453125 Z m 0,0"
+           id="path4832" />
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#84bd6662f0)"
+     id="g4842"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:#3a4055;fill-opacity:1;stroke:none;stroke-width:0.67261654;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="M 211.66667,175.29167 V 201.75 h 37.04166 L 254,196.45833 V 170 h -37.04167 z"
-       id="path3715-5-6-7-9-8-7-6-3-9"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="ccccccc" />
-    <text
-       xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:Titillium;letter-spacing:0px;word-spacing:0px;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
-       x="232.99562"
-       y="181.63109"
-       id="text1062-7"><tspan
-         sodipodi:role="line"
-         id="tspan1060-4"
-         x="232.99562"
-         y="181.63109"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87777805px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332">C++</tspan><tspan
-         sodipodi:role="line"
-         x="232.99562"
-         y="194.86026"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87777805px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332"
-         id="tspan1064-9">Type</tspan></text>
+       fill="#306998"
+       d="m 125.32813,548.84766 v -43.44532 c 0,-0.52343 0.0508,-1.04297 0.15625,-1.55859 0.10156,-0.51563 0.25,-1.01563 0.45312,-1.5 0.19922,-0.48438 0.44531,-0.94531 0.73438,-1.38281 0.29296,-0.4336 0.62109,-0.83985 0.99218,-1.21094 0.3711,-0.37109 0.77344,-0.70313 1.20703,-0.99219 0.4375,-0.29297 0.89453,-0.53906 1.37891,-0.73828 0.48437,-0.20312 0.98437,-0.35547 1.49609,-0.45703 0.51172,-0.10156 1.03125,-0.15234 1.55469,-0.15234 h 72.875 c 0.52344,0 1.04297,0.0508 1.55859,0.15234 0.51172,0.10156 1.01172,0.25391 1.49219,0.45703 0.48438,0.19922 0.94531,0.44531 1.37891,0.73828 0.4375,0.28906 0.83984,0.6211 1.20703,0.99219 0.37109,0.37109 0.70312,0.77734 0.99219,1.21094 0.29297,0.4375 0.53906,0.89843 0.73828,1.38281 0.19922,0.48437 0.35156,0.98437 0.45312,1.5 0.10157,0.51562 0.15235,1.03516 0.15235,1.55859 v 43.44532 c 0,0.52734 -0.0508,1.04687 -0.15235,1.5625 -0.10156,0.51171 -0.2539,1.01171 -0.45312,1.5 -0.19922,0.48437 -0.44531,0.94531 -0.73828,1.3789 -0.28907,0.4375 -0.6211,0.84375 -0.99219,1.21485 -0.36719,0.37109 -0.76953,0.69921 -1.20703,0.99218 -0.4336,0.29297 -0.89453,0.53907 -1.37891,0.73828 -0.48047,0.20313 -0.98047,0.35547 -1.49219,0.45704 -0.51562,0.10156 -1.03515,0.15234 -1.55859,0.15234 h -72.875 c -0.52344,0 -1.04297,-0.0508 -1.55469,-0.15234 -0.51172,-0.10157 -1.01172,-0.25391 -1.49609,-0.45704 -0.48438,-0.19921 -0.94141,-0.44531 -1.37891,-0.73828 -0.43359,-0.29297 -0.83593,-0.62109 -1.20703,-0.99218 -0.37109,-0.3711 -0.69922,-0.77735 -0.99218,-1.21485 -0.28907,-0.43359 -0.53516,-0.89453 -0.73438,-1.3789 -0.20312,-0.48829 -0.35156,-0.98829 -0.45312,-1.5 -0.10547,-0.51563 -0.15625,-1.03516 -0.15625,-1.5625 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4840" />
+  </g>
+  <g
+     clip-path="url(#728d290ff8)"
+     id="g4846"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:#848895;fill-opacity:1;stroke:none;stroke-width:0.52087492;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 211.66667,131.63542 v 11.90625 h 48.94791 l 3.96875,-3.96875 v -11.90625 h -48.94791 z"
-       id="path3715-5-6-7-9-8-7-6-56-0-1"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="ccccccc" />
-    <text
-       xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:7.05555534px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
-       x="220.67876"
-       y="137.35394"
-       id="text1032-4-7"><tspan
-         sodipodi:role="line"
-         id="tspan1030-6-0"
-         x="220.67876"
-         y="137.35394"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:7.05555534px;font-family:Titillium;-inkscape-font-specification:'Titillium, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332">PythonType</tspan></text>
+       fill="#306998"
+       d="m 214.60547,505.40234 v 43.44532 c 0,0.55468 -0.0508,1.10546 -0.16016,1.64843 -0.10937,0.54688 -0.26953,1.07422 -0.48047,1.58594 -0.21093,0.51563 -0.47265,1 -0.77734,1.46484 -0.30859,0.46094 -0.66016,0.88672 -1.05078,1.28125 -0.39063,0.39063 -0.81641,0.74219 -1.27735,1.05079 -0.46093,0.30859 -0.94531,0.57031 -1.45703,0.78125 -0.51172,0.21093 -1.03906,0.37109 -1.58203,0.48046 -0.54297,0.10938 -1.08984,0.16407 -1.64453,0.16407 h -72.87109 c -0.55469,0 -1.10547,-0.0547 -1.64844,-0.16407 -0.54297,-0.10937 -1.07031,-0.26953 -1.57813,-0.48046 -0.51171,-0.21094 -1,-0.47266 -1.46093,-0.78125 -0.46094,-0.3086 -0.88672,-0.66016 -1.27735,-1.05079 -0.39062,-0.39453 -0.73828,-0.82031 -1.04687,-1.28125 -0.30859,-0.46484 -0.56641,-0.94921 -0.78125,-1.46484 -0.21094,-0.51172 -0.37109,-1.03906 -0.47656,-1.58594 -0.10938,-0.54297 -0.16407,-1.09375 -0.16407,-1.64843 v -43.44532 c 0,-0.55468 0.0547,-1.10156 0.16407,-1.64843 0.10547,-0.54297 0.26562,-1.07422 0.47656,-1.58594 0.21484,-0.51172 0.47266,-1 0.78125,-1.46094 0.30859,-0.46094 0.65625,-0.89062 1.04687,-1.28125 0.39063,-0.39453 0.81641,-0.74609 1.27735,-1.05469 0.46093,-0.30859 0.94922,-0.5664 1.46093,-0.78125 0.50782,-0.21093 1.03516,-0.37109 1.57813,-0.48047 0.54297,-0.10937 1.09375,-0.16015 1.64844,-0.16015 h 72.87109 c 0.55469,0 1.10156,0.0547 1.64453,0.16015 0.54297,0.10938 1.07031,0.26954 1.58203,0.48438 0.51172,0.21094 1,0.47266 1.45703,0.78125 0.46094,0.30859 0.88672,0.65625 1.27735,1.05078 0.39453,0.39063 0.74219,0.82031 1.05078,1.28125 0.30469,0.46094 0.56641,0.94922 0.77734,1.46094 0.21094,0.51172 0.3711,1.04297 0.48047,1.58594 0.10938,0.54687 0.16016,1.09375 0.16016,1.64843 z m -88.81641,43.44532 c 0,0.49609 0.0469,0.98437 0.14453,1.46875 0.0937,0.48828 0.23829,0.95703 0.42579,1.41406 0.1875,0.45703 0.42187,0.89453 0.69531,1.30469 0.27344,0.41015 0.58594,0.79296 0.93359,1.14062 0.34766,0.35156 0.73047,0.66406 1.14063,0.9375 0.41015,0.27734 0.84375,0.50781 1.29687,0.69922 0.45703,0.1875 0.92578,0.33203 1.41016,0.42578 0.48437,0.0977 0.97265,0.14453 1.46875,0.14453 h 72.87109 c 0.49609,0 0.98438,-0.0469 1.46875,-0.14453 0.48438,-0.0937 0.95313,-0.23828 1.41016,-0.42578 0.45312,-0.19141 0.88672,-0.42188 1.29687,-0.69922 0.41016,-0.27344 0.78906,-0.58594 1.14063,-0.9375 0.34765,-0.34766 0.66015,-0.73047 0.93359,-1.14062 0.27344,-0.41016 0.50781,-0.84766 0.69531,-1.30469 0.1875,-0.45703 0.33203,-0.92578 0.42578,-1.41406 0.0977,-0.48438 0.14454,-0.97266 0.14454,-1.46875 v -43.44532 c 0,-0.49218 -0.0469,-0.98437 -0.14454,-1.46875 -0.0937,-0.48437 -0.23828,-0.95703 -0.42578,-1.41406 -0.1875,-0.45703 -0.42187,-0.89062 -0.69531,-1.30469 -0.27344,-0.41015 -0.58594,-0.78906 -0.93359,-1.14062 -0.35157,-0.35156 -0.73047,-0.66406 -1.14063,-0.9375 -0.41015,-0.27344 -0.84375,-0.50781 -1.29687,-0.69531 -0.45703,-0.19141 -0.92578,-0.33204 -1.41016,-0.42969 -0.48437,-0.0977 -0.97266,-0.14453 -1.46875,-0.14453 h -72.87109 c -0.4961,0 -0.98438,0.0469 -1.46875,0.14453 -0.48438,0.0976 -0.95313,0.23828 -1.41016,0.42969 -0.45312,0.1875 -0.88672,0.42187 -1.29687,0.69531 -0.41016,0.27344 -0.79297,0.58594 -1.14063,0.9375 -0.34765,0.35156 -0.66015,0.73047 -0.93359,1.14062 -0.27344,0.41407 -0.50781,0.84766 -0.69531,1.30469 -0.1875,0.45703 -0.33204,0.92969 -0.42579,1.41406 -0.0977,0.48438 -0.14453,0.97657 -0.14453,1.46875 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4844" />
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4854"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(143.38693,521.34911)"
+       id="g4852">
+      <g
+         id="g4850">
+        <path
+           d="M 5.875,-4.046875 H 2.8125 V 0 H 1.46875 V -12.015625 H 5.875 c 1.300781,0 2.265625,0.320313 2.890625,0.953125 0.625,0.636719 0.9375,1.609375 0.9375,2.921875 0,2.730469 -1.277344,4.09375 -3.828125,4.09375 z M 2.8125,-5.21875 h 3.03125 c 1.65625,0 2.484375,-0.972656 2.484375,-2.921875 0,-0.925781 -0.199219,-1.601563 -0.59375,-2.03125 -0.386719,-0.4375 -1.015625,-0.65625 -1.890625,-0.65625 H 2.8125 Z m 0,0"
+           id="path4848" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4862"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(153.67768,521.34911)"
+       id="g4860">
+      <g
+         id="g4858">
+        <path
+           d="M 0.4375,-8.671875 H 1.734375 L 3.90625,-1.125 h 0.578125 l 2.1875,-7.546875 H 7.96875 L 4.359375,3.859375 H 3.0625 L 4.1875,0 H 2.90625 Z m 0,0"
+           id="path4856" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4870"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(162.05952,521.34911)"
+       id="g4868">
+      <g
+         id="g4866">
+        <path
+           d="M 5.75,-7.546875 H 2.984375 v 4.140625 c 0,1 0.070313,1.65625 0.21875,1.96875 0.144531,0.3125 0.488281,0.46875 1.03125,0.46875 L 5.78125,-1.078125 5.875,0 C 5.09375,0.125 4.5,0.1875 4.09375,0.1875 3.195312,0.1875 2.570312,-0.03125 2.21875,-0.46875 1.875,-0.90625 1.703125,-1.742188 1.703125,-2.984375 v -4.5625 H 0.46875 v -1.125 h 1.234375 v -2.65625 h 1.28125 v 2.65625 H 5.75 Z m 0,0"
+           id="path4864" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4878"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(168.15067,521.34911)"
+       id="g4876">
+      <g
+         id="g4874">
+        <path
+           d="M 2.546875,0 H 1.25 v -12.46875 h 1.296875 v 4.28125 c 0.925781,-0.445312 1.816406,-0.671875 2.671875,-0.671875 1.164062,0 1.945312,0.3125 2.34375,0.9375 0.394531,0.625 0.59375,1.742187 0.59375,3.34375 V 0 H 6.859375 V -4.546875 C 6.859375,-5.753906 6.738281,-6.578125 6.5,-7.015625 6.257812,-7.460938 5.757812,-7.6875 5,-7.6875 c -0.730469,0 -1.4375,0.132812 -2.125,0.390625 l -0.328125,0.125 z m 0,0"
+           id="path4872" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4886"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(177.4696,521.34911)"
+       id="g4884">
+      <g
+         id="g4882">
+        <path
+           d="m 0.875,-4.359375 c 0,-1.582031 0.28125,-2.726563 0.84375,-3.4375 0.5625,-0.707031 1.515625,-1.0625 2.859375,-1.0625 1.351563,0 2.3125,0.355469 2.875,1.0625 0.5625,0.710937 0.84375,1.855469 0.84375,3.4375 C 8.296875,-2.773438 8.03125,-1.625 7.5,-0.90625 6.96875,-0.1875 5.992188,0.171875 4.578125,0.171875 c -1.40625,0 -2.375,-0.359375 -2.90625,-1.078125 C 1.140625,-1.625 0.875,-2.773438 0.875,-4.359375 Z M 2.203125,-4.375 c 0,1.261719 0.148437,2.148438 0.453125,2.65625 0.3125,0.511719 0.957031,0.765625 1.9375,0.765625 0.976562,0 1.617188,-0.25 1.921875,-0.75 C 6.816406,-2.210938 6.96875,-3.101562 6.96875,-4.375 6.96875,-5.644531 6.796875,-6.519531 6.453125,-7 6.117188,-7.476562 5.5,-7.71875 4.59375,-7.71875 3.6875,-7.71875 3.0625,-7.476562 2.71875,-7 2.375,-6.519531 2.203125,-5.644531 2.203125,-4.375 Z m 0,0"
+           id="path4880" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4894"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(186.63236,521.34911)"
+       id="g4892">
+      <g
+         id="g4890">
+        <path
+           d="M 2.546875,0 H 1.25 v -8.671875 h 1.28125 v 0.59375 c 0.9375,-0.519531 1.832031,-0.78125 2.6875,-0.78125 1.164062,0 1.945312,0.3125 2.34375,0.9375 0.394531,0.625 0.59375,1.742187 0.59375,3.34375 V 0 H 6.875 v -4.546875 c 0,-1.207031 -0.121094,-2.03125 -0.359375,-2.46875 C 6.273438,-7.460938 5.769531,-7.6875 5,-7.6875 c -0.375,0 -0.765625,0.058594 -1.171875,0.171875 -0.40625,0.105469 -0.726563,0.210937 -0.953125,0.3125 l -0.328125,0.15625 z m 0,0"
+           id="path4888" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4902"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(145.18979,545.60918)"
+       id="g4900">
+      <g
+         id="g4898">
+        <path
+           d="m 0.21875,-10.8125 v -1.203125 h 8.6875 V -10.8125 H 5.25 V 0 H 3.921875 v -10.8125 z m 0,0"
+           id="path4896" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4910"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(154.31784,545.60918)"
+       id="g4908">
+      <g
+         id="g4906">
+        <path
+           d="M 0.4375,-8.671875 H 1.734375 L 3.90625,-1.125 h 0.578125 l 2.1875,-7.546875 H 7.96875 L 4.359375,3.859375 H 3.0625 L 4.1875,0 H 2.90625 Z m 0,0"
+           id="path4904" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4918"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(162.69968,545.60918)"
+       id="g4916">
+      <g
+         id="g4914">
+        <path
+           d="M 1.25,3.859375 V -8.671875 H 2.53125 V -8.0625 c 0.882812,-0.53125 1.753906,-0.796875 2.609375,-0.796875 1.09375,0 1.890625,0.355469 2.390625,1.0625 0.5,0.699219 0.75,1.855469 0.75,3.46875 0,1.605469 -0.292969,2.757813 -0.875,3.453125 C 6.820312,-0.175781 5.851562,0.171875 4.5,0.171875 c -0.710938,0 -1.359375,-0.0625 -1.953125,-0.1875 v 3.875 z M 4.953125,-7.6875 c -0.355469,0 -0.730469,0.058594 -1.125,0.171875 C 3.429688,-7.398438 3.113281,-7.285156 2.875,-7.171875 L 2.546875,-7 v 5.859375 c 0.820313,0.125 1.445313,0.1875 1.875,0.1875 0.9375,0 1.59375,-0.265625 1.96875,-0.796875 0.382813,-0.53125 0.578125,-1.394531 0.578125,-2.59375 0,-1.207031 -0.171875,-2.066406 -0.515625,-2.578125 -0.34375,-0.507813 -0.84375,-0.765625 -1.5,-0.765625 z m 0,0"
+           id="path4912" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4926"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(171.84508,545.60918)"
+       id="g4924">
+      <g
+         id="g4922">
+        <path
+           d="m 7.15625,-1.078125 0.5,-0.046875 0.03125,1.015625 C 6.375,0.078125 5.25,0.171875 4.3125,0.171875 3.0625,0.171875 2.175781,-0.1875 1.65625,-0.90625 1.132812,-1.632812 0.875,-2.757812 0.875,-4.28125 c 0,-3.050781 1.207031,-4.578125 3.625,-4.578125 1.164062,0 2.035156,0.328125 2.609375,0.984375 0.582031,0.65625 0.875,1.683594 0.875,3.078125 l -0.0625,1 H 2.1875 c 0,0.960937 0.171875,1.671875 0.515625,2.140625 0.351563,0.460938 0.957031,0.6875 1.8125,0.6875 0.863281,0 1.742187,-0.035156 2.640625,-0.109375 z M 6.6875,-4.84375 c 0,-1.0625 -0.171875,-1.8125 -0.515625,-2.25 C 5.828125,-7.539062 5.269531,-7.765625 4.5,-7.765625 c -0.773438,0 -1.351562,0.234375 -1.734375,0.703125 -0.386719,0.460938 -0.585937,1.199219 -0.59375,2.21875 z m 0,0"
+           id="path4920" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4932"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(180.6087,545.60918)"
+       id="g4930">
+      <g
+         id="g4928" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4940"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(184.42651,545.60918)"
+       id="g4938">
+      <g
+         id="g4936">
+        <path
+           d="m 8.515625,0 h -7.3125 v -1.125 l 3.34375,-3.53125 c 0.582031,-0.601562 1.003906,-1.0625 1.265625,-1.375 0.269531,-0.3125 0.507812,-0.679688 0.71875,-1.109375 0.21875,-0.425781 0.328125,-0.851563 0.328125,-1.28125 0,-0.738281 -0.203125,-1.257813 -0.609375,-1.5625 -0.40625,-0.300781 -1.039062,-0.453125 -1.890625,-0.453125 -0.75,0 -1.589844,0.101562 -2.515625,0.296875 l -0.453125,0.09375 -0.109375,-1.109375 c 1.101562,-0.3125 2.238281,-0.46875 3.40625,-0.46875 1.164062,0 2.046875,0.246094 2.640625,0.734375 0.601563,0.492187 0.90625,1.265625 0.90625,2.328125 0,0.8125 -0.183594,1.523438 -0.546875,2.125 -0.355469,0.605469 -0.976562,1.328125 -1.859375,2.171875 L 2.78125,-1.15625 h 5.734375 z m 0,0"
+           id="path4934" />
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#00b091b271)"
+     id="g4944"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:none;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow1Lend)"
-       d="M 111.125,143.54167 H 127"
-       id="path1149"
-       inkscape:connector-curvature="0" />
+       fill="#306998"
+       d="m 125.32813,618.67969 v -43.44532 c 0,-0.52343 0.0508,-1.04687 0.15625,-1.55859 0.10156,-0.51562 0.25,-1.01562 0.45312,-1.5 0.19922,-0.48437 0.44531,-0.94531 0.73438,-1.38281 0.29296,-0.4375 0.62109,-0.83985 0.99218,-1.21094 0.3711,-0.37109 0.77344,-0.70312 1.20703,-0.99609 0.4375,-0.28907 0.89453,-0.53907 1.37891,-0.73828 0.48437,-0.19922 0.98437,-0.35157 1.49609,-0.45313 0.51172,-0.10547 1.03125,-0.15625 1.55469,-0.15625 h 72.875 c 0.52344,0 1.04297,0.0508 1.55859,0.15625 0.51172,0.10156 1.01172,0.25391 1.49219,0.45313 0.48438,0.19921 0.94531,0.44921 1.37891,0.73828 0.4375,0.29297 0.83984,0.625 1.20703,0.99609 0.37109,0.37109 0.70312,0.77344 0.99219,1.21094 0.29297,0.4375 0.53906,0.89844 0.73828,1.38281 0.19922,0.48438 0.35156,0.98438 0.45312,1.5 0.10157,0.51172 0.15235,1.03516 0.15235,1.55859 v 43.44532 c 0,0.52343 -0.0508,1.04297 -0.15235,1.55859 -0.10156,0.51563 -0.2539,1.01563 -0.45312,1.5 -0.19922,0.48438 -0.44531,0.94531 -0.73828,1.38281 -0.28907,0.4375 -0.6211,0.83985 -0.99219,1.21094 -0.36719,0.37109 -0.76953,0.70313 -1.20703,0.99609 -0.4336,0.28907 -0.89453,0.53516 -1.37891,0.73829 -0.48047,0.19921 -0.98047,0.35156 -1.49219,0.45312 -0.51562,0.10547 -1.03515,0.15625 -1.55859,0.15625 h -72.875 c -0.52344,0 -1.04297,-0.0508 -1.55469,-0.15625 -0.51172,-0.10156 -1.01172,-0.25391 -1.49609,-0.45312 -0.48438,-0.20313 -0.94141,-0.44922 -1.37891,-0.73829 -0.43359,-0.29296 -0.83593,-0.625 -1.20703,-0.99609 -0.37109,-0.37109 -0.69922,-0.77344 -0.99218,-1.21094 -0.28907,-0.4375 -0.53516,-0.89843 -0.73438,-1.38281 -0.20312,-0.48437 -0.35156,-0.98437 -0.45312,-1.5 -0.10547,-0.51562 -0.15625,-1.03516 -0.15625,-1.55859 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4942" />
+  </g>
+  <g
+     clip-path="url(#be13ebcaaa)"
+     id="g4948"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:none;stroke:#000000;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;marker-end:url(#marker1443)"
-       d="M 111.125,175.29167 H 127"
-       id="path1433"
-       inkscape:connector-curvature="0" />
+       fill="#306998"
+       d="m 214.60547,575.23437 v 43.44141 c 0,0.55859 -0.0508,1.10547 -0.16016,1.65234 -0.10937,0.54297 -0.26953,1.07422 -0.48047,1.58594 -0.21093,0.51172 -0.47265,1 -0.77734,1.46094 -0.30859,0.46094 -0.66016,0.89062 -1.05078,1.28125 -0.39063,0.39453 -0.81641,0.74219 -1.27735,1.05078 -0.46093,0.30859 -0.94531,0.57031 -1.45703,0.78125 -0.51172,0.21484 -1.03906,0.375 -1.58203,0.48438 -0.54297,0.10546 -1.08984,0.16015 -1.64453,0.16015 h -72.87109 c -0.55469,0 -1.10547,-0.0547 -1.64844,-0.16015 -0.54297,-0.10938 -1.07031,-0.26954 -1.57813,-0.48438 -0.51171,-0.21094 -1,-0.47266 -1.46093,-0.78125 -0.46094,-0.30859 -0.88672,-0.65625 -1.27735,-1.05078 -0.39062,-0.39063 -0.73828,-0.82031 -1.04687,-1.28125 -0.30859,-0.46094 -0.56641,-0.94922 -0.78125,-1.46094 -0.21094,-0.51172 -0.37109,-1.04297 -0.47656,-1.58594 -0.10938,-0.54687 -0.16407,-1.09375 -0.16407,-1.65234 v -43.44141 c 0,-0.55468 0.0547,-1.10546 0.16407,-1.64843 0.10547,-0.54688 0.26562,-1.07422 0.47656,-1.58594 0.21484,-0.51563 0.47266,-1.00391 0.78125,-1.46484 0.30859,-0.46094 0.65625,-0.88672 1.04687,-1.28125 0.39063,-0.39063 0.81641,-0.74219 1.27735,-1.05079 0.46093,-0.30859 0.94922,-0.57031 1.46093,-0.78125 0.50782,-0.21484 1.03516,-0.375 1.57813,-0.48046 0.54297,-0.10938 1.09375,-0.16407 1.64844,-0.16407 h 72.87109 c 0.55469,0 1.10156,0.0547 1.64453,0.16407 0.54297,0.10937 1.07031,0.26953 1.58203,0.48046 0.51172,0.21094 1,0.47266 1.45703,0.78125 0.46094,0.3086 0.88672,0.66016 1.27735,1.05079 0.39453,0.39453 0.74219,0.82031 1.05078,1.28125 0.30469,0.46484 0.56641,0.94921 0.77734,1.46484 0.21094,0.51172 0.3711,1.03906 0.48047,1.58594 0.10938,0.54297 0.16016,1.09375 0.16016,1.64843 z m -88.81641,43.44141 c 0,0.49609 0.0469,0.98828 0.14453,1.47266 0.0937,0.48437 0.23829,0.95703 0.42579,1.41406 0.1875,0.45703 0.42187,0.89062 0.69531,1.30078 0.27344,0.41406 0.58594,0.79297 0.93359,1.14453 0.34766,0.34766 0.73047,0.66016 1.14063,0.9375 0.41015,0.27344 0.84375,0.50781 1.29687,0.69531 0.45703,0.19141 0.92578,0.33204 1.41016,0.42969 0.48437,0.0977 0.97265,0.14453 1.46875,0.14453 h 72.87109 c 0.49609,0 0.98438,-0.0469 1.46875,-0.14453 0.48438,-0.0976 0.95313,-0.23828 1.41016,-0.42969 0.45312,-0.1875 0.88672,-0.42187 1.29687,-0.69531 0.41016,-0.27734 0.78906,-0.58984 1.14063,-0.9375 0.34765,-0.35156 0.66015,-0.73047 0.93359,-1.14453 0.27344,-0.41016 0.50781,-0.84375 0.69531,-1.30078 0.1875,-0.45703 0.33203,-0.92969 0.42578,-1.41406 0.0977,-0.48438 0.14454,-0.97657 0.14454,-1.47266 v -43.44141 c 0,-0.49609 -0.0469,-0.98437 -0.14454,-1.46875 -0.0937,-0.48828 -0.23828,-0.95703 -0.42578,-1.41406 -0.1875,-0.45703 -0.42187,-0.89453 -0.69531,-1.30469 -0.27344,-0.41015 -0.58594,-0.79296 -0.93359,-1.14062 -0.35157,-0.35156 -0.73047,-0.66406 -1.14063,-0.9375 -0.41015,-0.27734 -0.84375,-0.50781 -1.29687,-0.69922 -0.45703,-0.1875 -0.92578,-0.33203 -1.41016,-0.42969 -0.48437,-0.0937 -0.97266,-0.14453 -1.46875,-0.14453 h -72.87109 c -0.4961,0 -0.98438,0.0508 -1.46875,0.14453 -0.48438,0.0977 -0.95313,0.24219 -1.41016,0.42969 -0.45312,0.19141 -0.88672,0.42188 -1.29687,0.69922 -0.41016,0.27344 -0.79297,0.58594 -1.14063,0.9375 -0.34765,0.34766 -0.66015,0.73047 -0.93359,1.14062 -0.27344,0.41016 -0.50781,0.84766 -0.69531,1.30469 -0.1875,0.45703 -0.33204,0.92578 -0.42579,1.41406 -0.0977,0.48438 -0.14453,0.97266 -0.14453,1.46875 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path4946" />
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4956"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(143.38693,591.17926)"
+       id="g4954">
+      <g
+         id="g4952">
+        <path
+           d="M 5.875,-4.046875 H 2.8125 V 0 H 1.46875 V -12.015625 H 5.875 c 1.300781,0 2.265625,0.320313 2.890625,0.953125 0.625,0.636719 0.9375,1.609375 0.9375,2.921875 0,2.730469 -1.277344,4.09375 -3.828125,4.09375 z M 2.8125,-5.21875 h 3.03125 c 1.65625,0 2.484375,-0.972656 2.484375,-2.921875 0,-0.925781 -0.199219,-1.601563 -0.59375,-2.03125 -0.386719,-0.4375 -1.015625,-0.65625 -1.890625,-0.65625 H 2.8125 Z m 0,0"
+           id="path4950" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4964"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(153.67768,591.17926)"
+       id="g4962">
+      <g
+         id="g4960">
+        <path
+           d="M 0.4375,-8.671875 H 1.734375 L 3.90625,-1.125 h 0.578125 l 2.1875,-7.546875 H 7.96875 L 4.359375,3.859375 H 3.0625 L 4.1875,0 H 2.90625 Z m 0,0"
+           id="path4958" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4972"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(162.05952,591.17926)"
+       id="g4970">
+      <g
+         id="g4968">
+        <path
+           d="M 5.75,-7.546875 H 2.984375 v 4.140625 c 0,1 0.070313,1.65625 0.21875,1.96875 0.144531,0.3125 0.488281,0.46875 1.03125,0.46875 L 5.78125,-1.078125 5.875,0 C 5.09375,0.125 4.5,0.1875 4.09375,0.1875 3.195312,0.1875 2.570312,-0.03125 2.21875,-0.46875 1.875,-0.90625 1.703125,-1.742188 1.703125,-2.984375 v -4.5625 H 0.46875 v -1.125 h 1.234375 v -2.65625 h 1.28125 v 2.65625 H 5.75 Z m 0,0"
+           id="path4966" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4980"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(168.15067,591.17926)"
+       id="g4978">
+      <g
+         id="g4976">
+        <path
+           d="M 2.546875,0 H 1.25 v -12.46875 h 1.296875 v 4.28125 c 0.925781,-0.445312 1.816406,-0.671875 2.671875,-0.671875 1.164062,0 1.945312,0.3125 2.34375,0.9375 0.394531,0.625 0.59375,1.742187 0.59375,3.34375 V 0 H 6.859375 V -4.546875 C 6.859375,-5.753906 6.738281,-6.578125 6.5,-7.015625 6.257812,-7.460938 5.757812,-7.6875 5,-7.6875 c -0.730469,0 -1.4375,0.132812 -2.125,0.390625 l -0.328125,0.125 z m 0,0"
+           id="path4974" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4988"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(177.4696,591.17926)"
+       id="g4986">
+      <g
+         id="g4984">
+        <path
+           d="m 0.875,-4.359375 c 0,-1.582031 0.28125,-2.726563 0.84375,-3.4375 0.5625,-0.707031 1.515625,-1.0625 2.859375,-1.0625 1.351563,0 2.3125,0.355469 2.875,1.0625 0.5625,0.710937 0.84375,1.855469 0.84375,3.4375 C 8.296875,-2.773438 8.03125,-1.625 7.5,-0.90625 6.96875,-0.1875 5.992188,0.171875 4.578125,0.171875 c -1.40625,0 -2.375,-0.359375 -2.90625,-1.078125 C 1.140625,-1.625 0.875,-2.773438 0.875,-4.359375 Z M 2.203125,-4.375 c 0,1.261719 0.148437,2.148438 0.453125,2.65625 0.3125,0.511719 0.957031,0.765625 1.9375,0.765625 0.976562,0 1.617188,-0.25 1.921875,-0.75 C 6.816406,-2.210938 6.96875,-3.101562 6.96875,-4.375 6.96875,-5.644531 6.796875,-6.519531 6.453125,-7 6.117188,-7.476562 5.5,-7.71875 4.59375,-7.71875 3.6875,-7.71875 3.0625,-7.476562 2.71875,-7 2.375,-6.519531 2.203125,-5.644531 2.203125,-4.375 Z m 0,0"
+           id="path4982" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g4996"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(186.63236,591.17926)"
+       id="g4994">
+      <g
+         id="g4992">
+        <path
+           d="M 2.546875,0 H 1.25 v -8.671875 h 1.28125 v 0.59375 c 0.9375,-0.519531 1.832031,-0.78125 2.6875,-0.78125 1.164062,0 1.945312,0.3125 2.34375,0.9375 0.394531,0.625 0.59375,1.742187 0.59375,3.34375 V 0 H 6.875 v -4.546875 c 0,-1.207031 -0.121094,-2.03125 -0.359375,-2.46875 C 6.273438,-7.460938 5.769531,-7.6875 5,-7.6875 c -0.375,0 -0.765625,0.058594 -1.171875,0.171875 -0.40625,0.105469 -0.726563,0.210937 -0.953125,0.3125 l -0.328125,0.15625 z m 0,0"
+           id="path4990" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g5004"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(145.18979,615.43933)"
+       id="g5002">
+      <g
+         id="g5000">
+        <path
+           d="m 0.21875,-10.8125 v -1.203125 h 8.6875 V -10.8125 H 5.25 V 0 H 3.921875 v -10.8125 z m 0,0"
+           id="path4998" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g5012"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(154.31784,615.43933)"
+       id="g5010">
+      <g
+         id="g5008">
+        <path
+           d="M 0.4375,-8.671875 H 1.734375 L 3.90625,-1.125 h 0.578125 l 2.1875,-7.546875 H 7.96875 L 4.359375,3.859375 H 3.0625 L 4.1875,0 H 2.90625 Z m 0,0"
+           id="path5006" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g5020"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(162.69968,615.43933)"
+       id="g5018">
+      <g
+         id="g5016">
+        <path
+           d="M 1.25,3.859375 V -8.671875 H 2.53125 V -8.0625 c 0.882812,-0.53125 1.753906,-0.796875 2.609375,-0.796875 1.09375,0 1.890625,0.355469 2.390625,1.0625 0.5,0.699219 0.75,1.855469 0.75,3.46875 0,1.605469 -0.292969,2.757813 -0.875,3.453125 C 6.820312,-0.175781 5.851562,0.171875 4.5,0.171875 c -0.710938,0 -1.359375,-0.0625 -1.953125,-0.1875 v 3.875 z M 4.953125,-7.6875 c -0.355469,0 -0.730469,0.058594 -1.125,0.171875 C 3.429688,-7.398438 3.113281,-7.285156 2.875,-7.171875 L 2.546875,-7 v 5.859375 c 0.820313,0.125 1.445313,0.1875 1.875,0.1875 0.9375,0 1.59375,-0.265625 1.96875,-0.796875 0.382813,-0.53125 0.578125,-1.394531 0.578125,-2.59375 0,-1.207031 -0.171875,-2.066406 -0.515625,-2.578125 -0.34375,-0.507813 -0.84375,-0.765625 -1.5,-0.765625 z m 0,0"
+           id="path5014" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g5028"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(171.84508,615.43933)"
+       id="g5026">
+      <g
+         id="g5024">
+        <path
+           d="m 7.15625,-1.078125 0.5,-0.046875 0.03125,1.015625 C 6.375,0.078125 5.25,0.171875 4.3125,0.171875 3.0625,0.171875 2.175781,-0.1875 1.65625,-0.90625 1.132812,-1.632812 0.875,-2.757812 0.875,-4.28125 c 0,-3.050781 1.207031,-4.578125 3.625,-4.578125 1.164062,0 2.035156,0.328125 2.609375,0.984375 0.582031,0.65625 0.875,1.683594 0.875,3.078125 l -0.0625,1 H 2.1875 c 0,0.960937 0.171875,1.671875 0.515625,2.140625 0.351563,0.460938 0.957031,0.6875 1.8125,0.6875 0.863281,0 1.742187,-0.035156 2.640625,-0.109375 z M 6.6875,-4.84375 c 0,-1.0625 -0.171875,-1.8125 -0.515625,-2.25 C 5.828125,-7.539062 5.269531,-7.765625 4.5,-7.765625 c -0.773438,0 -1.351562,0.234375 -1.734375,0.703125 -0.386719,0.460938 -0.585937,1.199219 -0.59375,2.21875 z m 0,0"
+           id="path5022" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g5034"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(180.6087,615.43933)"
+       id="g5032">
+      <g
+         id="g5030" />
+    </g>
+  </g>
+  <g
+     fill="#fefeff"
+     fill-opacity="1"
+     id="g5042"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       transform="translate(184.42651,615.43933)"
+       id="g5040">
+      <g
+         id="g5038">
+        <path
+           d="m 1.25,-11.15625 c 1.082031,-0.320312 2.242188,-0.484375 3.484375,-0.484375 1.25,0 2.148437,0.242187 2.703125,0.71875 0.5625,0.46875 0.84375,1.226563 0.84375,2.265625 0,0.53125 -0.074219,0.917969 -0.21875,1.15625 -0.148438,0.230469 -0.261719,0.414062 -0.34375,0.546875 -0.085938,0.125 -0.199219,0.246094 -0.34375,0.359375 -0.25,0.199219 -0.453125,0.335938 -0.609375,0.40625 l -0.1875,0.125 c 0.675781,0.25 1.175781,0.5625 1.5,0.9375 0.320313,0.375 0.484375,0.992188 0.484375,1.84375 0,1.167969 -0.304688,2.039062 -0.90625,2.609375 -0.59375,0.5625 -1.53125,0.84375 -2.8125,0.84375 -1.023438,0 -2.101562,-0.1171875 -3.234375,-0.34375 l -0.53125,-0.125 0.125,-1.09375 C 2.453125,-1.128906 3.617188,-1 4.703125,-1 6.359375,-1.019531 7.1875,-1.765625 7.1875,-3.234375 c 0,-1.375 -0.789062,-2.085937 -2.359375,-2.140625 h -2.3125 v -1.15625 h 2.3125 c 0.488281,0 0.957031,-0.191406 1.40625,-0.578125 0.445313,-0.382813 0.671875,-0.894531 0.671875,-1.53125 0,-0.632813 -0.183594,-1.09375 -0.546875,-1.375 -0.355469,-0.289063 -0.953125,-0.4375 -1.796875,-0.4375 -0.929688,0 -1.839844,0.08984 -2.734375,0.265625 L 1.375,-10.109375 Z m 0,0"
+           id="path5036" />
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#12ef88673f)"
+     id="g5046"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:none;stroke:#000000;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;marker-end:url(#marker1479)"
-       d="M 111.125,196.45834 127,185.875"
-       id="path1469"
-       inkscape:connector-curvature="0" />
+       fill="#000000"
+       d="m 293.44922,366.47266 15.07422,-14.98829 -15.07422,-15.01171 -3.37891,3.36328 9.27344,9.26562 h -56.76953 v 4.76563 h 56.76953 l -9.27344,9.23828 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path5044" />
+  </g>
+  <g
+     clip-path="url(#4425bd08fe)"
+     id="g5050"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:none;stroke:#000000;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;marker-end:url(#marker1521)"
-       d="M 111.125,217.625 127,201.75"
-       id="path1511"
-       inkscape:connector-curvature="0" />
+       fill="#000000"
+       d="m 554.83203,366.47266 15.07422,-14.98829 -15.07422,-15.01171 -3.38281,3.36328 9.27344,9.26562 h -56.76954 v 4.76563 h 56.76954 l -9.27344,9.23828 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path5048" />
+  </g>
+  <g
+     clip-path="url(#29f410bb45)"
+     id="g5054"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:none;stroke:#000000;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;marker-end:url(#marker1569)"
-       d="m 195.79166,185.875 h 15.875"
-       id="path1559"
-       inkscape:connector-curvature="0" />
+       fill="#000000"
+       d="m 554.83203,542.04297 15.07422,-14.98438 -15.07422,-15.01562 -3.38281,3.36719 9.27344,9.26562 h -56.76954 v 4.76563 h 56.76954 l -9.27344,9.23828 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path5052" />
+  </g>
+  <g
+     clip-path="url(#8612924f50)"
+     id="g5058"
+     transform="translate(-69.242111,-250.64609)">
     <path
-       style="fill:none;stroke:#000000;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;marker-end:url(#marker1623)"
-       d="m 195.79166,138.25001 h 15.875"
-       id="path1613"
-       inkscape:connector-curvature="0" />
+       fill="#000000"
+       d="m 287.44531,541.73437 15.07422,-14.98828 -15.07422,-15.01172 -3.3789,3.36329 9.26953,9.26562 h -56.76953 v 4.76953 h 56.76953 l -9.26953,9.23438 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path5056" />
+  </g>
+  <g
+     clip-path="url(#9616827f5c)"
+     id="g5068"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       clip-path="url(#6d6215aef9)"
+       id="g5066">
+      <g
+         clip-path="url(#506e24dd3d)"
+         id="g5064">
+        <g
+           clip-path="url(#85c10bb5f0)"
+           id="g5062">
+          <path
+             fill="#000000"
+             d="m 279.46094,488.74609 19.99609,-7.21093 -7.32031,-19.98047 -4.48438,1.625 4.48828,12.3125 -51.44921,-23.98828 -2.01563,4.32031 51.44922,23.98828 -12.30469,4.45312 z m 0,0"
+             fill-opacity="1"
+             fill-rule="nonzero"
+             id="path5060" />
+        </g>
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#96382ab88a)"
+     id="g5078"
+     transform="translate(-69.242111,-250.64609)">
+    <g
+       clip-path="url(#8ee2f579d3)"
+       id="g5076">
+      <g
+         clip-path="url(#c24345751d)"
+         id="g5074">
+        <g
+           clip-path="url(#6c1dc82097)"
+           id="g5072">
+          <path
+             fill="#000000"
+             d="m 279.46094,565.48437 19.99609,7.21094 -7.32031,19.97656 -4.48438,-1.62109 4.48828,-12.31641 -51.44921,23.99219 -2.01563,-4.32031 51.44922,-23.99219 -12.30469,-4.44922 z m 0,0"
+             fill-opacity="1"
+             fill-rule="nonzero"
+             id="path5070" />
+        </g>
+      </g>
+    </g>
   </g>
 </svg>
diff --git a/sources/shiboken6/doc/images/genrunnerarch.png b/sources/shiboken6/doc/images/genrunnerarch.png
deleted file mode 100644
index db1077cd0..000000000
--- a/sources/shiboken6/doc/images/genrunnerarch.png
+++ /dev/null
diff --git a/sources/shiboken6/doc/images/genrunnerarch.svg b/sources/shiboken6/doc/images/genrunnerarch.svg
deleted file mode 100644
index ea7eb73e7..000000000
--- a/sources/shiboken6/doc/images/genrunnerarch.svg
+++ /dev/null
@@ -1,654 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="980"
-   height="380"
-   id="svg2"
-   sodipodi:version="0.32"
-   inkscape:version="0.47pre4 r22446"
-   version="1.0"
-   sodipodi:docname="genrunnerarch.svg"
-   inkscape:output_extension="org.inkscape.output.svg.inkscape"
-   inkscape:export-filename="genrunnerarch.png"
-   inkscape:export-xdpi="56.549999"
-   inkscape:export-ydpi="56.549999">
-  <defs
-     id="defs4">
-    <marker
-       inkscape:stockid="EmptyDiamondL"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="EmptyDiamondL"
-       style="overflow:visible">
-      <path
-         id="path3930"
-         d="M 0,-7.0710768 -7.0710894,0 0,7.0710589 7.0710462,0 0,-7.0710768 z"
-         style="fill:#ffffff;fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="scale(0.8,0.8)" />
-    </marker>
-    <marker
-       inkscape:stockid="EmptyTriangleInL"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="EmptyTriangleInL"
-       style="overflow:visible">
-      <path
-         id="path3975"
-         d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
-         style="fill:#ffffff;fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.8,0,0,-0.8,4.8,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Sstart"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Sstart"
-       style="overflow:visible">
-      <path
-         id="path3835"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(0.2,0,0,0.2,1.2,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Mend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Mend"
-       style="overflow:visible">
-      <path
-         id="path3832"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.4,0,0,-0.4,-4,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Tail"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Tail"
-       style="overflow:visible">
-      <g
-         id="g3859"
-         transform="scale(-1.2,-1.2)">
-        <path
-           id="path3861"
-           d="M -3.8048674,-3.9585227 0.54352094,0"
-           style="fill:none;stroke:#000000;stroke-width:0.80000001;stroke-linecap:round;marker-start:none;marker-end:none" />
-        <path
-           id="path3863"
-           d="M -1.2866832,-3.9585227 3.0617053,0"
-           style="fill:none;stroke:#000000;stroke-width:0.80000001;stroke-linecap:round;marker-start:none;marker-end:none" />
-        <path
-           id="path3865"
-           d="M 1.3053582,-3.9585227 5.6537466,0"
-           style="fill:none;stroke:#000000;stroke-width:0.80000001;stroke-linecap:round;marker-start:none;marker-end:none" />
-        <path
-           id="path3867"
-           d="M -3.8048674,4.1775838 0.54352094,0.21974226"
-           style="fill:none;stroke:#000000;stroke-width:0.80000001;stroke-linecap:round;marker-start:none;marker-end:none" />
-        <path
-           id="path3869"
-           d="M -1.2866832,4.1775838 3.0617053,0.21974226"
-           style="fill:none;stroke:#000000;stroke-width:0.80000001;stroke-linecap:round;marker-start:none;marker-end:none" />
-        <path
-           id="path3871"
-           d="M 1.3053582,4.1775838 5.6537466,0.21974226"
-           style="fill:none;stroke:#000000;stroke-width:0.80000001;stroke-linecap:round;marker-start:none;marker-end:none" />
-      </g>
-    </marker>
-    <marker
-       inkscape:stockid="Arrow2Lend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow2Lend"
-       style="overflow:visible">
-      <path
-         id="path3636"
-         style="font-size:12px;fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
-         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
-         transform="matrix(-1.1,0,0,-1.1,-1.1,0)" />
-    </marker>
-    <inkscape:perspective
-       sodipodi:type="inkscape:persp3d"
-       inkscape:vp_x="0 : 526.18109 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_z="744.09448 : 526.18109 : 1"
-       inkscape:persp3d-origin="372.04724 : 350.78739 : 1"
-       id="perspective10" />
-    <inkscape:perspective
-       id="perspective3033"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3881"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3915"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3956"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective5100"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective5322"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective5365"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective5391"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="EmptyTriangleInL"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="EmptyTriangleInL-4"
-       style="overflow:visible">
-      <path
-         id="path3975-9"
-         d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
-         style="fill:#ffffff;fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.8,0,0,-0.8,4.8,0)" />
-    </marker>
-    <inkscape:perspective
-       id="perspective5621"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective5643"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="EmptyDiamondL"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="EmptyDiamondL-7"
-       style="overflow:visible">
-      <path
-         id="path3930-7"
-         d="M 0,-7.0710768 -7.0710894,0 0,7.0710589 7.0710462,0 0,-7.0710768 z"
-         style="fill:#ffffff;fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="scale(0.8,0.8)" />
-    </marker>
-  </defs>
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     gridtolerance="10000"
-     guidetolerance="10"
-     objecttolerance="10"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="1.0716799"
-     inkscape:cx="460.27913"
-     inkscape:cy="148.01364"
-     inkscape:document-units="px"
-     inkscape:current-layer="layer1"
-     showgrid="false"
-     inkscape:window-width="1862"
-     inkscape:window-height="1019"
-     inkscape:window-x="20"
-     inkscape:window-y="89"
-     showguides="true"
-     inkscape:guide-bbox="true"
-     inkscape:window-maximized="0" />
-  <metadata
-     id="metadata7">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(472.44407,-697.53823)">
-    <flowRoot
-       xml:space="preserve"
-       id="flowRoot3229"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       transform="translate(2.0918751e-6,-6.0000008)"><flowRegion
-         id="flowRegion3231"><rect
-           id="rect3233"
-           width="125.74072"
-           height="40.5849"
-           x="388.45547"
-           y="279.5423" /></flowRegion><flowPara
-         id="flowPara3235" /></flowRoot>    <g
-       id="g5867"
-       transform="translate(6.7062969,-7.6922472)">
-      <rect
-         rx="3.4968286"
-         ry="5.2462597"
-         y="713.31403"
-         x="-472.05276"
-         height="363.61459"
-         width="393.78473"
-         id="rect3609"
-         style="fill:#e4fae3;fill-opacity:0.65882353;stroke:#8eff89;stroke-width:0.78260708;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
-      <text
-         transform="scale(1.0000266,0.9999734)"
-         id="text3601"
-         y="742.43872"
-         x="-275.16165"
-         style="font-size:38.71272278px;font-style:normal;font-weight:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-         xml:space="preserve"><tspan
-           id="tspan3605"
-           style="font-size:27.09890556px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans"
-           y="742.43872"
-           x="-275.16165"
-           sodipodi:role="line"><tspan
-             id="tspan2508"
-             style="font-weight:bold">API Extractor</tspan></tspan></text>
-      <g
-         transform="matrix(0.9678438,0,0,0.9677923,-587.62742,-106.48682)"
-         id="g3763">
-        <rect
-           style="fill:#bff3bc;fill-opacity:1;stroke:#0af400;stroke-width:0.79775763;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
-           id="rect3737"
-           width="244.82956"
-           height="101.59812"
-           x="267.06232"
-           y="905.13727"
-           ry="3.1522403"
-           rx="2.4096873" />
-        <text
-           xml:space="preserve"
-           style="font-size:40px;font-style:normal;font-weight:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-           x="389.39117"
-           y="931.86993"
-           id="text3739"><tspan
-             sodipodi:role="line"
-             x="389.39117"
-             y="931.86993"
-             style="font-size:22px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans Bold"
-             id="tspan3741">ApiExtractor</tspan><tspan
-             id="tspan2523"
-             sodipodi:role="line"
-             x="389.39117"
-             y="953.38947"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">commands the parsing and</tspan><tspan
-             id="tspan2517"
-             sodipodi:role="line"
-             x="389.39117"
-             y="973.38947"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">building of the data model</tspan><tspan
-             id="tspan2519"
-             sodipodi:role="line"
-             x="389.39117"
-             y="993.38947"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">and calls the user generators</tspan></text>
-      </g>
-      <rect
-         rx="2.1814992"
-         ry="5.2485871"
-         y="713.45312"
-         x="219.72128"
-         height="363.77597"
-         width="274.11292"
-         id="rect9190"
-         style="fill:#b8d1f1;fill-opacity:0.51184836;stroke:#0045a4;stroke-width:0.6182732;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
-      <text
-         transform="scale(1.0000266,0.9999734)"
-         id="text9192"
-         y="742.66901"
-         x="357.65579"
-         style="font-size:38.71272278px;font-style:normal;font-weight:normal;text-align:center;text-anchor:middle;fill:#002e7a;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-         xml:space="preserve"><tspan
-           id="tspan9194"
-           style="font-size:27.09890556px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#002e7a;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans"
-           y="742.66901"
-           x="357.65579"
-           sodipodi:role="line"><tspan
-             id="tspan2512"
-             style="font-weight:bold;fill:#002e7a;fill-opacity:1">front-end</tspan><tspan
-             id="tspan2514"
-             style="font-size:22px;fill:#002e7a;fill-opacity:1" /></tspan></text>
-      <rect
-         rx="2.2192271"
-         ry="5.2485123"
-         y="713.23639"
-         x="-68.659073"
-         height="363.77075"
-         width="278.85358"
-         id="rect9190-9"
-         style="fill:#cbe990;fill-opacity:0.51184836;stroke:#6ca400;stroke-width:0.62359226;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
-      <text
-         transform="scale(1.0000266,0.9999734)"
-         id="text9192-3"
-         y="741.71094"
-         x="70.291061"
-         style="font-size:38.71272278px;font-style:normal;font-weight:normal;text-align:center;text-anchor:middle;fill:#050800;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-         xml:space="preserve"><tspan
-           id="tspan9194-7"
-           style="font-size:26px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:center;text-anchor:middle;fill:#050800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans"
-           y="741.71094"
-           x="70.291061"
-           sodipodi:role="line">Generator Runner</tspan></text>
-      <g
-         transform="matrix(0.9678438,0,0,0.9677923,-687.04869,-241.74888)"
-         id="g9234-4">
-        <rect
-           style="fill:#addc52;fill-opacity:1;stroke:#6ca400;stroke-width:0.73640609;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
-           id="rect9206-4"
-           width="218.17299"
-           height="83.517967"
-           x="694.6994"
-           y="1044.8701"
-           ry="2.5912752"
-           rx="2.4978092" />
-        <text
-           xml:space="preserve"
-           style="font-size:40px;font-style:normal;font-weight:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-           x="803.78589"
-           y="1072.3693"
-           id="text9208-3"><tspan
-             sodipodi:role="line"
-             x="803.78589"
-             y="1072.3693"
-             style="font-size:22px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:center;text-anchor:middle;fill:#050800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans Bold"
-             id="tspan9210-0">Generator</tspan><tspan
-             id="tspan9222-8"
-             sodipodi:role="line"
-             x="803.78589"
-             y="1093.8888"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#050800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">base class for front-end</tspan><tspan
-             id="tspan3946"
-             sodipodi:role="line"
-             x="803.78589"
-             y="1113.8888"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#050800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">output classes</tspan></text>
-      </g>
-      <g
-         transform="matrix(0.9678438,0,0,0.9677923,-726.09128,-46.791689)"
-         id="g10497-6">
-        <rect
-           style="fill:#89b3e7;fill-opacity:1;stroke:#0049a4;stroke-width:1.04736876;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
-           id="rect10444-8"
-           width="256.05252"
-           height="143.95157"
-           x="990.81482"
-           y="843.58032"
-           ry="4.4663219"
-           rx="2.9314826" />
-        <text
-           xml:space="preserve"
-           style="font-size:40px;font-style:normal;font-weight:normal;text-align:center;text-anchor:middle;fill:#002758;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-           x="1118.0945"
-           y="873.04047"
-           id="text10446-8"><tspan
-             sodipodi:role="line"
-             x="1118.0945"
-             y="873.04047"
-             style="font-size:22px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:center;text-anchor:middle;fill:#002758;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans Bold"
-             id="tspan10448-4">SpecificGenerator</tspan><tspan
-             id="tspan4063"
-             sodipodi:role="line"
-             x="1118.0945"
-             y="894.56"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#002758;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">generators written for any</tspan><tspan
-             id="tspan5381"
-             sodipodi:role="line"
-             x="1118.0945"
-             y="914.56"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#002758;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">desired output,</tspan><tspan
-             id="tspan4065"
-             sodipodi:role="line"
-             x="1118.0945"
-             y="934.56"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#002758;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans"> e.g.: HppGenerator,</tspan><tspan
-             id="tspan4071"
-             sodipodi:role="line"
-             x="1118.0945"
-             y="954.56"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#002758;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">CppGenerator,</tspan><tspan
-             id="tspan4073"
-             sodipodi:role="line"
-             x="1118.0945"
-             y="974.56"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#002758;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">ConverterGenerator</tspan></text>
-      </g>
-      <path
-         sodipodi:nodetypes="cc"
-         transform="translate(109.91989,748.26874)"
-         id="path4056"
-         d="m -201.98482,41.728896 76.97065,5e-6"
-         style="fill:none;stroke:#000000;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:6, 1;stroke-dashoffset:0" />
-      <path
-         sodipodi:nodetypes="cc"
-         id="path4056-2"
-         d="m 197.04022,787.89746 35.38656,0"
-         style="fill:none;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0;marker-start:url(#EmptyTriangleInL)" />
-      <g
-         transform="matrix(0.9678438,0,0,0.9677923,-1010.4541,91.401187)"
-         id="g10497">
-        <rect
-           style="fill:#addc52;fill-opacity:1;stroke:#6ca400;stroke-width:0.88060772;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
-           id="rect10444"
-           width="256.21927"
-           height="101.69494"
-           x="990.73145"
-           y="843.49695"
-           ry="3.1552441"
-           rx="2.9333918" />
-        <text
-           xml:space="preserve"
-           style="font-size:40px;font-style:normal;font-weight:normal;text-align:start;text-anchor:start;fill:#035800;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-           x="1012.22"
-           y="870.08466"
-           id="text10446"><tspan
-             sodipodi:role="line"
-             x="1012.22"
-             y="870.08466"
-             style="font-size:22px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;text-anchor:start;fill:#050800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans Bold"
-             id="tspan10448">Generator App</tspan><tspan
-             id="tspan10456"
-             sodipodi:role="line"
-             x="1012.22"
-             y="891.60419"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;text-anchor:start;fill:#050800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">* loads generators</tspan><tspan
-             id="tspan5353"
-             sodipodi:role="line"
-             x="1012.22"
-             y="911.60419"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;text-anchor:start;fill:#050800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">* setup API Extractor</tspan><tspan
-             id="tspan5355"
-             sodipodi:role="line"
-             x="1012.22"
-             y="931.60419"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;text-anchor:start;fill:#050800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">* executes each generator</tspan></text>
-      </g>
-      <path
-         sodipodi:nodetypes="cc"
-         id="path4056-9"
-         d="m 72.409302,850.57374 0,56.99122"
-         style="fill:none;stroke:#000000;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:6, 1;stroke-dashoffset:0" />
-      <path
-         sodipodi:nodetypes="ccc"
-         id="path4056-2-0"
-         d="m -86.437722,825.54499 52.188784,0 0.06367,81.67009"
-         style="fill:none;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0;marker-start:url(#EmptyDiamondL)" />
-      <path
-         sodipodi:nodetypes="cc"
-         id="path4056-91"
-         d="m -394.83596,853.70064 0,121.42437"
-         style="fill:none;stroke:#000000;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:6, 1;stroke-dashoffset:0" />
-      <g
-         transform="matrix(0.9678438,0,0,0.9677923,-707.18032,-153.53291)"
-         id="g3809">
-        <rect
-           style="fill:#bff3bc;fill-opacity:1;stroke:#0af400;stroke-width:1.00168562;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
-           id="rect3785"
-           width="332.48172"
-           height="82.830231"
-           x="302.83319"
-           y="1068.9153"
-           ry="3.1461167"
-           rx="3.8065021" />
-        <text
-           xml:space="preserve"
-           style="font-size:40px;font-style:normal;font-weight:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-           x="469.03497"
-           y="1095.5493"
-           id="text3787"><tspan
-             id="tspan3791"
-             sodipodi:role="line"
-             x="469.03497"
-             y="1095.5493"
-             style="font-size:22px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans Bold">AbstractMetaBuilder</tspan><tspan
-             sodipodi:role="line"
-             x="469.03497"
-             y="1117.0688"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans"
-             id="tspan3807">builds the data model with information</tspan><tspan
-             id="tspan2545"
-             sodipodi:role="line"
-             x="469.03497"
-             y="1137.0688"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">from headers and binding directives</tspan><tspan
-             id="tspan3795"
-             sodipodi:role="line"
-             x="469.03497"
-             y="1157.0688"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans" /></text>
-      </g>
-      <g
-         transform="matrix(0.9678438,0,0,0.9677923,-755.89347,194.37862)"
-         id="g3709">
-        <rect
-           style="fill:#bff3bc;fill-opacity:1;stroke:#0af400;stroke-width:0.69825613;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
-           id="rect2821"
-           width="198.90968"
-           height="93.892342"
-           x="305.2475"
-           y="807.38849"
-           ry="2.6812849"
-           rx="2.1703238" />
-        <text
-           xml:space="preserve"
-           style="font-size:40px;font-style:normal;font-weight:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-           x="405.17499"
-           y="831.81903"
-           id="text3611"><tspan
-             id="tspan3687"
-             sodipodi:role="line"
-             x="405.17499"
-             y="831.81903"
-             style="font-size:22px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans Bold">TypeDatabase</tspan><tspan
-             id="tspan5641"
-             sodipodi:role="line"
-             x="405.17499"
-             y="853.33856"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">parses typesystem</tspan><tspan
-             id="tspan3689"
-             sodipodi:role="line"
-             x="405.17499"
-             y="873.33856"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">and stores information</tspan></text>
-      </g>
-      <g
-         transform="matrix(0.9678438,0,0,0.9677923,-589.50555,-13.923919)"
-         id="g3728">
-        <rect
-           style="fill:#bff3bc;fill-opacity:1;stroke:#0af400;stroke-width:0.54871088;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
-           id="rect3625"
-           width="117.15066"
-           height="86.355225"
-           x="133.25664"
-           y="809.36938"
-           ry="2.6793056"
-           rx="1.3412292" />
-        <text
-           xml:space="preserve"
-           style="font-size:40px;font-style:normal;font-weight:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-           x="191.58197"
-           y="838.75159"
-           id="text3627"><tspan
-             sodipodi:role="line"
-             x="191.58197"
-             y="838.75159"
-             style="font-size:22px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans Bold"
-             id="tspan3631">Parser</tspan><tspan
-             id="tspan3695"
-             sodipodi:role="line"
-             x="191.58197"
-             y="860.27112"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">parses the</tspan><tspan
-             id="tspan3697"
-             sodipodi:role="line"
-             x="191.58197"
-             y="880.27112"
-             style="font-size:16px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;fill:#035800;fill-opacity:1;font-family:Bitstream Vera Sans;-inkscape-font-specification:Bitstream Vera Sans">lib headers</tspan></text>
-      </g>
-      <path
-         sodipodi:nodetypes="ccc"
-         id="path4056-2-0-1"
-         d="m 197.39006,961.71122 158.27877,0 0.19429,-51.88885"
-         style="fill:none;stroke:#000000;stroke-width:1.38812411;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:8.32874408, 1.38812401;stroke-dashoffset:0;marker-start:none" />
-    </g>
-  </g>
-</svg>
diff --git a/sources/shiboken6/doc/images/qtforpython-underthehood.png b/sources/shiboken6/doc/images/qtforpython-underthehood.png
index 64e30b1c5..295cefcf9 100644
--- a/sources/shiboken6/doc/images/qtforpython-underthehood.png
+++ b/sources/shiboken6/doc/images/qtforpython-underthehood.png
diff --git a/sources/shiboken6/doc/images/qtforpython-underthehood.svg b/sources/shiboken6/doc/images/qtforpython-underthehood.svg
new file mode 100644
index 000000000..8924d9d4b
--- /dev/null
+++ b/sources/shiboken6/doc/images/qtforpython-underthehood.svg
@@ -0,0 +1,1502 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="972.87427"
+   zoomAndPan="magnify"
+   viewBox="0 0 729.6557 410.72465"
+   height="547.63287"
+   preserveAspectRatio="xMidYMid"
+   version="1.0"
+   id="svg684"
+   sodipodi:docname="qtforpython-underthehood.svg"
+   inkscape:version="1.2.2 (b0a8486541, 2022-12-01)"
+   inkscape:export-filename="qtforpython-underthehood.png"
+   inkscape:export-xdpi="96"
+   inkscape:export-ydpi="96"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview686"
+     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.80648148"
+     inkscape:cx="400.50517"
+     inkscape:cy="272.16992"
+     inkscape:window-width="2552"
+     inkscape:window-height="1432"
+     inkscape:window-x="1924"
+     inkscape:window-y="4"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg684" />
+  <defs
+     id="defs94">
+    <filter
+       x="0"
+       y="0"
+       width="1"
+       height="1"
+       id="941f55d5ad">
+      <feColorMatrix
+         values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0"
+         color-interpolation-filters="sRGB"
+         id="feColorMatrix2" />
+    </filter>
+    <filter
+       x="0"
+       y="0"
+       width="1"
+       height="1"
+       id="7900779894">
+      <feColorMatrix
+         values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0.2126 0.7152 0.0722 0 0"
+         color-interpolation-filters="sRGB"
+         id="feColorMatrix5" />
+    </filter>
+    <clipPath
+       id="43b70e6d50">
+      <path
+         d="m 329.69531,337.88281 h 134.25 v 134.25 h -134.25 z m 0,0"
+         clip-rule="nonzero"
+         id="path10" />
+    </clipPath>
+    <clipPath
+       id="5e0498f898">
+      <path
+         d="m 418.84375,430.04687 h 78 v 78 h -78 z m 0,0"
+         clip-rule="nonzero"
+         id="path13" />
+    </clipPath>
+    <clipPath
+       id="ee2fc7472f">
+      <path
+         d="m 296.76953,430.04687 h 77.87109 v 78 h -77.87109 z m 0,0"
+         clip-rule="nonzero"
+         id="path16" />
+    </clipPath>
+    <clipPath
+       id="e49c99af70">
+      <path
+         d="m 418.84375,307.19531 h 78 v 77.8711 h -78 z m 0,0"
+         clip-rule="nonzero"
+         id="path19" />
+    </clipPath>
+    <clipPath
+       id="9f18cca9db">
+      <path
+         d="m 296.76953,307.19531 h 77.87109 v 77.8711 h -77.87109 z m 0,0"
+         clip-rule="nonzero"
+         id="path22" />
+    </clipPath>
+    <clipPath
+       id="9c58565a54">
+      <path
+         d="m 240.875,207.47656 h 111.52734 v 82.5 H 240.875 Z m 0,0"
+         clip-rule="nonzero"
+         id="path25" />
+    </clipPath>
+    <clipPath
+       id="9d28a89d3d">
+      <path
+         d="m 46.855469,529 h 73.500001 v 30 H 46.855469 Z m 0,0"
+         clip-rule="nonzero"
+         id="path28" />
+    </clipPath>
+    <clipPath
+       id="0baef73a1e">
+      <path
+         d="m 163.94922,224.44922 h 69.75 v 72 h -69.75 z m 0,0"
+         clip-rule="nonzero"
+         id="path31" />
+    </clipPath>
+    <clipPath
+       id="1f4a27800a">
+      <path
+         d="M 62.34375,227.08203 H 153 V 293 H 62.34375 Z m 0,0"
+         clip-rule="nonzero"
+         id="path34" />
+    </clipPath>
+    <mask
+       id="e94e818b4b">
+      <g
+         filter="url(#941f55d5ad)"
+         id="g42">
+        <g
+           filter="url(#7900779894)"
+           transform="matrix(0.196004,0,0,0.194118,62.344152,227.08093)"
+           id="g40">
+          <image
+             x="0"
+             y="0"
+             width="463"
+             xlink:href="data:image/png;base64,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"
+             height="340"
+             preserveAspectRatio="xMidYMid"
+             id="image38" />
+        </g>
+      </g>
+    </mask>
+    <mask
+       id="8f2a27f6f4">
+      <g
+         filter="url(#941f55d5ad)"
+         id="g51">
+        <g
+           filter="url(#7900779894)"
+           transform="matrix(0.198482,0,0,0.198482,536.61425,471.98102)"
+           id="g49">
+          <image
+             x="0"
+             y="0"
+             width="461"
+             xlink:href="data:image/png;base64,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"
+             height="461"
+             preserveAspectRatio="xMidYMid"
+             id="image47" />
+        </g>
+      </g>
+    </mask>
+    <clipPath
+       id="9cd47c7ee3">
+      <path
+         d="m 268,534 h 119 v 74 H 268 Z m 0,0"
+         clip-rule="nonzero"
+         id="path55" />
+    </clipPath>
+    <clipPath
+       id="69785d3302">
+      <path
+         d="m 284.80469,510.52344 111.6914,32.23828 -23.91797,82.86719 -111.6914,-32.23829 z m 0,0"
+         clip-rule="nonzero"
+         id="path58" />
+    </clipPath>
+    <clipPath
+       id="9c0953b9a2">
+      <path
+         d="m 372.87891,625.72656 -111.69141,-32.23437 23.91797,-82.8711 111.6914,32.23828 z m 0,0"
+         clip-rule="nonzero"
+         id="path61" />
+    </clipPath>
+    <clipPath
+       id="8e32f12866">
+      <path
+         d="m 372.87891,625.72656 -111.69141,-32.23437 23.91797,-82.8711 111.6914,32.23828 z m 0,0"
+         clip-rule="nonzero"
+         id="path64" />
+    </clipPath>
+    <clipPath
+       id="a3af3eb6b6">
+      <path
+         d="m 698.37109,329 h 48.75 v 135.9375 h -48.75 z m 0,0"
+         clip-rule="nonzero"
+         id="path67" />
+    </clipPath>
+    <clipPath
+       id="31f8f05393">
+      <path
+         d="m 508,316 h 77 v 50 h -77 z m 0,0"
+         clip-rule="nonzero"
+         id="path70" />
+    </clipPath>
+    <clipPath
+       id="41889181af">
+      <path
+         d="M 594.73828,339.63672 520.52344,380.56641 506.03516,354.29687 580.25,313.36719 Z m 0,0"
+         clip-rule="nonzero"
+         id="path73" />
+    </clipPath>
+    <clipPath
+       id="fe9d13e8b4">
+      <path
+         d="m 520.6875,380.47656 74.21484,-40.92969 -14.48828,-26.26953 -74.21094,40.92969 z m 0,0"
+         clip-rule="nonzero"
+         id="path76" />
+    </clipPath>
+    <clipPath
+       id="6c6e35ef02">
+      <path
+         d="m 520.6875,380.47656 74.21484,-40.92969 -14.48828,-26.26953 -74.21094,40.92969 z m 0,0"
+         clip-rule="nonzero"
+         id="path79" />
+    </clipPath>
+    <clipPath
+       id="9d2f7452d2">
+      <path
+         d="m 544,250 h 60.1875 v 43.51172 H 544 Z m 0,0"
+         clip-rule="nonzero"
+         id="path82" />
+    </clipPath>
+    <clipPath
+       id="5d999a0038">
+      <path
+         d="M 543.4375,219 H 560 v 8 h -16.5625 z m 0,0"
+         clip-rule="nonzero"
+         id="path85" />
+    </clipPath>
+    <clipPath
+       id="a4f0b4e13e">
+      <path
+         d="m 548,215.51172 h 47 V 249 h -47 z m 0,0"
+         clip-rule="nonzero"
+         id="path88" />
+    </clipPath>
+    <clipPath
+       id="0ea259bc34">
+      <path
+         d="m 595,215.51172 h 6 V 249 h -6 z m 0,0"
+         clip-rule="nonzero"
+         id="path91" />
+    </clipPath>
+  </defs>
+  <rect
+     style="fill:#ffffff;stroke:none;stroke-width:0.75"
+     id="rect1721"
+     width="728.9057"
+     height="409.97464"
+     x="0.375"
+     y="0.375" />
+  <path
+     fill="#41cb51"
+     d="m 353.33158,222.2777 c -10.36328,0 -18.79687,-8.4336 -18.79687,-18.79688 0,-10.36328 8.43359,-18.79297 18.79687,-18.79297 10.35938,0 18.79297,8.42969 18.79297,18.79297 0,10.36328 -8.43359,18.79688 -18.79297,18.79688 z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path102" />
+  <g
+     clip-path="url(#43b70e6d50)"
+     id="g106"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#41cb51"
+       d="m 461.69141,394.18359 -14.32813,-2.33984 c -1.21484,-4.66797 -3.07422,-9.12891 -5.54687,-13.3125 l 8.37109,-11.92969 c 0.75,-1.07031 0.625,-2.51953 -0.29688,-3.4414 L 438.5,351.76953 c -0.92969,-0.93359 -2.40234,-1.05078 -3.46484,-0.28125 l -11.80469,8.48438 c -4.19141,-2.46485 -8.66016,-4.32032 -13.32422,-5.52735 l -2.51172,-14.33984 c -0.22656,-1.28516 -1.34375,-2.22266 -2.64844,-2.22266 h -16.10937 c -1.31641,0 -2.4375,0.95313 -2.65235,2.25391 l -2.33984,14.33984 c -4.60937,1.19922 -9.03516,3.03516 -13.19531,5.47656 l -11.86328,-8.47656 c -1.07032,-0.76172 -2.52735,-0.64062 -3.46094,0.28516 l -11.39063,11.39062 c -0.92187,0.91797 -1.05078,2.36719 -0.30078,3.4336 l 8.375,11.96484 c -2.46093,4.16406 -4.30859,8.60938 -5.51953,13.24609 l -14.34765,2.39063 c -1.29688,0.21484 -2.2461,1.33203 -2.2461,2.64453 v 16.11328 c 0,1.30078 0.9336,2.41406 2.21485,2.64063 l 14.35156,2.54687 c 1.20312,4.62891 3.04297,9.06641 5.49219,13.24219 l -8.48047,11.85156 c -0.76172,1.07031 -0.64063,2.53516 0.28515,3.46094 l 11.39063,11.39062 c 0.91797,0.91797 2.36719,1.04688 3.4375,0.30079 l 11.95703,-8.36719 c 4.14844,2.45312 8.58984,4.30078 13.24609,5.51953 l 2.39453,14.35937 c 0.21875,1.29297 1.33985,2.24219 2.65235,2.24219 h 16.10937 c 1.29688,0 2.41407,-0.93359 2.64063,-2.21484 l 2.54687,-14.35547 c 4.69141,-1.21484 9.17578,-3.07813 13.3711,-5.55469 l 11.9414,8.3711 c 1.07032,0.75 2.51953,0.625 3.44141,-0.29688 l 11.38281,-11.39062 c 0.9336,-0.92969 1.05078,-2.39844 0.28125,-3.46485 l -8.49219,-11.80469 c 2.46094,-4.1875 4.3125,-8.65234 5.51954,-13.3164 l 14.34375,-2.51563 c 1.28515,-0.22656 2.22265,-1.34375 2.22265,-2.64453 v -16.11328 c 0,-1.3125 -0.95312,-2.4375 -2.2539,-2.64844 z m -64.8711,43.04688 c -17.76953,0 -32.22265,-14.45703 -32.22265,-32.22266 0,-17.76562 14.45312,-32.21875 32.22265,-32.21875 17.76563,0 32.21875,14.45313 32.21875,32.21875 0,17.76563 -14.45312,32.22266 -32.21875,32.22266 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path104" />
+  </g>
+  <g
+     clip-path="url(#5e0498f898)"
+     id="g110"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#ffd43b"
+       d="m 473.52344,430.04687 c 0,30.17188 -24.50782,54.67969 -54.67969,54.67969 v 23.32031 c 43.08594,0 78,-34.91406 78,-78 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path108" />
+  </g>
+  <g
+     clip-path="url(#ee2fc7472f)"
+     id="g114"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#306998"
+       d="m 320.08984,430.04687 c 0,30.17188 24.50391,54.67969 54.67969,54.67969 v 23.32031 c -43.08594,0 -78,-34.91406 -78,-78 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path112" />
+  </g>
+  <g
+     clip-path="url(#e49c99af70)"
+     id="g118"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#306998"
+       d="m 473.52344,385.19531 c 0,-30.17187 -24.50782,-54.67969 -54.67969,-54.67969 v -23.32031 c 43.08594,0 78,34.91406 78,78 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path116" />
+  </g>
+  <g
+     clip-path="url(#9f18cca9db)"
+     id="g122"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#ffd43b"
+       d="m 320.08984,385.19531 c 0,-30.17187 24.50391,-54.67969 54.67969,-54.67969 v -23.32031 c -43.08594,0 -78,34.91406 -78,78 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path120" />
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g130"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(618.829,252.49077)"
+       id="g128">
+      <g
+         id="g126">
+        <path
+           d="m 10.484375,0.375 c -3.398437,0 -5.699219,-0.9375 -6.90625,-2.8125 -1.210937,-1.882812 -1.8125,-4.972656 -1.8125,-9.265625 0,-4.289063 0.609375,-7.347656 1.828125,-9.171875 1.21875,-1.820312 3.515625,-2.734375 6.890625,-2.734375 2.007813,0 4.222656,0.28125 6.640625,0.84375 L 17,-19.703125 C 14.957031,-20.066406 12.921875,-20.25 10.890625,-20.25 c -2.03125,0 -3.414063,0.605469 -4.140625,1.8125 -0.71875,1.210938 -1.078125,3.484375 -1.078125,6.828125 0,3.335937 0.347656,5.605469 1.046875,6.8125 0.695312,1.210937 2.0625,1.8125 4.09375,1.8125 2.039062,0 4.101562,-0.171875 6.1875,-0.515625 l 0.09375,3.125 c -2.324219,0.5 -4.527344,0.75 -6.609375,0.75 z m 0,0"
+           id="path124" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g138"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(636.53192,252.49077)"
+       id="g136">
+      <g
+         id="g134">
+        <path
+           d="m 11.1875,-7.21875 h -4.75 V 0 h -3.75 v -23.234375 h 8.5 c 5.269531,0 7.90625,2.601563 7.90625,7.796875 0,2.667969 -0.664062,4.703125 -1.984375,6.109375 -1.324219,1.40625 -3.296875,2.109375 -5.921875,2.109375 z m -4.75,-3.265625 h 4.71875 c 2.71875,0 4.078125,-1.648437 4.078125,-4.953125 0,-1.582031 -0.328125,-2.734375 -0.984375,-3.453125 -0.65625,-0.726563 -1.6875,-1.09375 -3.09375,-1.09375 H 6.4375 Z m 0,0"
+           id="path132" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g146"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(655.82879,252.49077)"
+       id="g144">
+      <g
+         id="g142">
+        <path
+           d="M 0.671875,-16.96875 H 4.3125 l 3.59375,13.8125 H 8.8125 l 3.609375,-13.8125 h 3.65625 L 9.640625,7.296875 H 6 L 8.046875,0 H 5.125 Z m 0,0"
+           id="path140" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g154"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(671.76817,252.49077)"
+       id="g152">
+      <g
+         id="g150">
+        <path
+           d="M 11.359375,-13.8125 H 6.6875 v 7.46875 c 0,1.375 0.097656,2.292969 0.296875,2.75 0.207031,0.449219 0.726563,0.671875 1.5625,0.671875 l 2.78125,-0.09375 L 11.5,-0.0625 C 9.988281,0.226562 8.835938,0.375 8.046875,0.375 c -1.929687,0 -3.25,-0.4375 -3.96875,-1.3125 -0.710937,-0.882812 -1.0625,-2.550781 -1.0625,-5 v -7.875 H 0.84375 v -3.15625 H 3.015625 V -21.875 H 6.6875 v 4.90625 h 4.671875 z m 0,0"
+           id="path148" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g162"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(683.16307,252.49077)"
+       id="g160">
+      <g
+         id="g158">
+        <path
+           d="M 5.9375,0 H 2.234375 V -24.015625 H 5.9375 v 7.9375 c 1.675781,-0.832031 3.222656,-1.25 4.640625,-1.25 2.257813,0 3.800781,0.640625 4.625,1.921875 0.832031,1.273438 1.25,3.375 1.25,6.3125 V 0 H 12.75 v -8.984375 c 0,-1.832031 -0.195312,-3.132813 -0.578125,-3.90625 -0.386719,-0.769531 -1.199219,-1.15625 -2.4375,-1.15625 -1.085937,0 -2.167969,0.183594 -3.25,0.546875 L 5.9375,-13.296875 Z m 0,0"
+           id="path156" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g170"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(700.9338,252.49077)"
+       id="g168">
+      <g
+         id="g166">
+        <path
+           d="m 3.171875,-15.125 c 1.164063,-1.46875 3.101563,-2.203125 5.8125,-2.203125 2.71875,0 4.65625,0.734375 5.8125,2.203125 1.164063,1.46875 1.75,3.671875 1.75,6.609375 0,2.9375 -0.570313,5.15625 -1.703125,6.65625 -1.125,1.492187 -3.078125,2.234375 -5.859375,2.234375 -2.78125,0 -4.742187,-0.742188 -5.875,-2.234375 -1.125,-1.5 -1.6875,-3.71875 -1.6875,-6.65625 0,-2.9375 0.582031,-5.140625 1.75,-6.609375 z M 5.9375,-4.109375 C 6.457031,-3.203125 7.472656,-2.75 8.984375,-2.75 c 1.519531,0 2.539063,-0.453125 3.0625,-1.359375 0.519531,-0.90625 0.78125,-2.382813 0.78125,-4.4375 0,-2.0625 -0.28125,-3.519531 -0.84375,-4.375 -0.554687,-0.863281 -1.554687,-1.296875 -3,-1.296875 -1.449219,0 -2.449219,0.433594 -3,1.296875 -0.554687,0.855469 -0.828125,2.3125 -0.828125,4.375 0,2.054687 0.257812,3.53125 0.78125,4.4375 z m 0,0"
+           id="path164" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g178"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(718.16191,252.49077)"
+       id="g176">
+      <g
+         id="g174">
+        <path
+           d="M 5.9375,0 H 2.234375 V -16.96875 H 5.90625 v 1.0625 c 1.644531,-0.945312 3.203125,-1.421875 4.671875,-1.421875 2.257813,0 3.800781,0.640625 4.625,1.921875 0.832031,1.273438 1.25,3.375 1.25,6.3125 V 0 H 12.78125 v -8.984375 c 0,-1.832031 -0.199219,-3.132813 -0.59375,-3.90625 -0.398438,-0.769531 -1.203125,-1.15625 -2.421875,-1.15625 -1.148437,0 -2.257813,0.230469 -3.328125,0.6875 l -0.5,0.203125 z m 0,0"
+           id="path172" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g186"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(618.829,286.99077)"
+       id="g184">
+      <g
+         id="g182">
+        <path
+           d="m 2.6875,0 v -23.234375 h 14.640625 v 3.28125 H 6.4375 v 6.59375 h 8.859375 v 3.25 H 6.4375 v 6.78125 H 17.328125 V 0 Z m 0,0"
+           id="path180" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g194"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(636.83714,286.99077)"
+       id="g192">
+      <g
+         id="g190">
+        <path
+           d="m 0.609375,-16.96875 h 3.9375 l 3.328125,5.875 3.359375,-5.875 H 15.15625 L 10.109375,-8.609375 15.15625,0 H 11.234375 L 7.875,-5.796875 4.546875,0 h -3.9375 L 5.53125,-8.515625 Z m 0,0"
+           id="path188" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g202"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(651.82693,286.99077)"
+       id="g200">
+      <g
+         id="g198">
+        <path
+           d="M 11.359375,-13.8125 H 6.6875 v 7.46875 c 0,1.375 0.097656,2.292969 0.296875,2.75 0.207031,0.449219 0.726563,0.671875 1.5625,0.671875 l 2.78125,-0.09375 L 11.5,-0.0625 C 9.988281,0.226562 8.835938,0.375 8.046875,0.375 c -1.929687,0 -3.25,-0.4375 -3.96875,-1.3125 -0.710937,-0.882812 -1.0625,-2.550781 -1.0625,-5 v -7.875 H 0.84375 v -3.15625 H 3.015625 V -21.875 H 6.6875 v 4.90625 h 4.671875 z m 0,0"
+           id="path196" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g210"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(663.22182,286.99077)"
+       id="g208">
+      <g
+         id="g206">
+        <path
+           d="m 14.3125,-3.046875 0.953125,-0.109375 0.0625,2.75 C 12.753906,0.113281 10.472656,0.375 8.484375,0.375 5.972656,0.375 4.164062,-0.3125 3.0625,-1.6875 1.96875,-3.070312 1.421875,-5.28125 1.421875,-8.3125 c 0,-6.007812 2.453125,-9.015625 7.359375,-9.015625 4.75,0 7.125,2.589844 7.125,7.765625 l -0.234375,2.640625 H 5.15625 c 0.019531,1.40625 0.320312,2.4375 0.90625,3.09375 0.59375,0.65625 1.691406,0.984375 3.296875,0.984375 1.601563,0 3.253906,-0.066406 4.953125,-0.203125 z m -2.03125,-6.71875 c 0,-1.675781 -0.265625,-2.847656 -0.796875,-3.515625 -0.53125,-0.664062 -1.433594,-1 -2.703125,-1 -1.261719,0 -2.183594,0.355469 -2.765625,1.0625 -0.574219,0.699219 -0.871094,1.851562 -0.890625,3.453125 z m 0,0"
+           id="path204" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g218"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(679.70382,286.99077)"
+       id="g216">
+      <g
+         id="g214">
+        <path
+           d="M 5.9375,0 H 2.234375 V -16.96875 H 5.90625 v 1.0625 c 1.644531,-0.945312 3.203125,-1.421875 4.671875,-1.421875 2.257813,0 3.800781,0.640625 4.625,1.921875 0.832031,1.273438 1.25,3.375 1.25,6.3125 V 0 H 12.78125 v -8.984375 c 0,-1.832031 -0.199219,-3.132813 -0.59375,-3.90625 -0.398438,-0.769531 -1.203125,-1.15625 -2.421875,-1.15625 -1.148437,0 -2.257813,0.230469 -3.328125,0.6875 l -0.5,0.203125 z m 0,0"
+           id="path212" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g226"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(697.47455,286.99077)"
+       id="g224">
+      <g
+         id="g222">
+        <path
+           d="m 14.015625,-13.46875 c -2.679687,-0.363281 -4.617187,-0.546875 -5.8125,-0.546875 -1.199219,0 -2.03125,0.148437 -2.5,0.4375 -0.460937,0.28125 -0.6875,0.730469 -0.6875,1.34375 0,0.605469 0.253906,1.03125 0.765625,1.28125 0.507812,0.25 1.707031,0.542969 3.59375,0.875 1.894531,0.324219 3.238281,0.835937 4.03125,1.53125 0.789062,0.699219 1.1875,1.945313 1.1875,3.734375 0,1.78125 -0.574219,3.09375 -1.71875,3.9375 -1.148438,0.8359375 -2.8125,1.25 -5,1.25 -1.386719,0 -3.132812,-0.195312 -5.234375,-0.578125 L 1.59375,-0.375 1.734375,-3.453125 c 2.707031,0.355469 4.660156,0.53125 5.859375,0.53125 1.195312,0 2.050781,-0.144531 2.5625,-0.4375 0.507812,-0.289063 0.765625,-0.773437 0.765625,-1.453125 0,-0.675781 -0.246094,-1.144531 -0.734375,-1.40625 C 9.707031,-6.476562 8.546875,-6.757812 6.703125,-7.0625 4.859375,-7.375 3.503906,-7.859375 2.640625,-8.515625 c -0.855469,-0.65625 -1.28125,-1.851563 -1.28125,-3.59375 0,-1.738281 0.59375,-3.035156 1.78125,-3.890625 1.1875,-0.863281 2.707031,-1.296875 4.5625,-1.296875 1.445313,0 3.222656,0.183594 5.328125,0.546875 l 1.046875,0.203125 z m 0,0"
+           id="path220" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g234"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(712.63391,286.99077)"
+       id="g232">
+      <g
+         id="g230">
+        <path
+           d="M 2.234375,0 V -16.96875 H 5.9375 V 0 Z m 0,-19.84375 V -23.75 H 5.9375 v 3.90625 z m 0,0"
+           id="path228" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g242"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(720.06086,286.99077)"
+       id="g240">
+      <g
+         id="g238">
+        <path
+           d="m 3.171875,-15.125 c 1.164063,-1.46875 3.101563,-2.203125 5.8125,-2.203125 2.71875,0 4.65625,0.734375 5.8125,2.203125 1.164063,1.46875 1.75,3.671875 1.75,6.609375 0,2.9375 -0.570313,5.15625 -1.703125,6.65625 -1.125,1.492187 -3.078125,2.234375 -5.859375,2.234375 -2.78125,0 -4.742187,-0.742188 -5.875,-2.234375 -1.125,-1.5 -1.6875,-3.71875 -1.6875,-6.65625 0,-2.9375 0.582031,-5.140625 1.75,-6.609375 z M 5.9375,-4.109375 C 6.457031,-3.203125 7.472656,-2.75 8.984375,-2.75 c 1.519531,0 2.539063,-0.453125 3.0625,-1.359375 0.519531,-0.90625 0.78125,-2.382813 0.78125,-4.4375 0,-2.0625 -0.28125,-3.519531 -0.84375,-4.375 -0.554687,-0.863281 -1.554687,-1.296875 -3,-1.296875 -1.449219,0 -2.449219,0.433594 -3,1.296875 -0.554687,0.855469 -0.828125,2.3125 -0.828125,4.375 0,2.054687 0.257812,3.53125 0.78125,4.4375 z m 0,0"
+           id="path236" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g250"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(737.28897,286.99077)"
+       id="g248">
+      <g
+         id="g246">
+        <path
+           d="M 5.9375,0 H 2.234375 V -16.96875 H 5.90625 v 1.0625 c 1.644531,-0.945312 3.203125,-1.421875 4.671875,-1.421875 2.257813,0 3.800781,0.640625 4.625,1.921875 0.832031,1.273438 1.25,3.375 1.25,6.3125 V 0 H 12.78125 v -8.984375 c 0,-1.832031 -0.199219,-3.132813 -0.59375,-3.90625 -0.398438,-0.769531 -1.203125,-1.15625 -2.421875,-1.15625 -1.148437,0 -2.257813,0.230469 -3.328125,0.6875 l -0.5,0.203125 z m 0,0"
+           id="path244" />
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#9c58565a54)"
+     id="g254"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#09102b"
+       d="m 321.85156,262.05469 c -0.89844,-1.01172 -1.60547,-1.91016 -2.41406,-2.70703 -2.69531,-2.64454 -5.30078,-5.39844 -8.1875,-7.82422 -3.11328,-2.61719 -7.58984,-1.91016 -10.45703,1.125 -0.71485,0.75 -1.97656,0.98437 -3.11328,1.51172 -0.48828,1.21093 0.67187,1.74609 1.39062,2.42578 6.50781,6.16797 11.5625,13.44922 15.94531,21.17187 1.67969,2.95313 2.80469,6.23047 4.07813,9.40235 0.99609,2.48828 1.125,2.84375 3.84766,2.625 4.85546,-0.39063 9.08593,-2.03907 12.14453,-6.20313 5.32812,-7.23437 11.07422,-14.17187 15.0664,-22.29687 0.64453,-1.32032 1.125,-2.72657 2.01563,-4.89844 -3.98438,0.71484 -7.26172,0.6875 -9.36719,3.84765 -1.28906,1.9375 -2.60547,3.85157 -4.38281,6.4961 -0.45703,-2.78125 -0.73828,-4.70313 -1.08203,-6.60547 -2.60547,-14.33203 -8.38672,-27.26563 -19.23438,-37.11719 -9.86719,-8.97656 -21.45703,-15.17969 -35.35156,-15.35156 -11.67188,-0.13672 -21.69531,4.42969 -30.45313,11.76562 -3.5039,2.94141 -6.47265,6.53516 -9.58593,9.92188 -0.8086,0.87891 -1.25,2.07422 -1.85938,3.13672 0.23438,0.22656 0.47266,0.45312 0.70703,0.67578 1.4336,-0.88672 2.92188,-1.69922 4.27735,-2.69531 0.84375,-0.625 1.49609,-1.51563 2.20312,-2.3125 9.07813,-10.24219 20.54297,-12.97657 33.53125,-10.1875 9.91797,2.1289 18.11719,7.46484 25.00391,14.77343 7.28125,7.70313 12.21875,16.77735 15.17578,26.94141 0.13672,0.44922 0.24609,0.91406 0.32031,1.375 0.0156,0.20703 -0.0937,0.43359 -0.21875,1.00391 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path252" />
+  </g>
+  <g
+     clip-path="url(#9d28a89d3d)"
+     id="g258"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#09102b"
+       d="m 46.824219,529.01953 v 29.27344 h 73.558591 v -29.27344 z m 28.085937,22.82422 c -0.01563,0 -0.01563,0 -0.01563,0 h -3.992187 c -0.0625,0 -0.125,-0.0469 -0.167969,-0.0937 L 67.273438,546.34766 63.78125,551.75 c -0.03125,0.0469 -0.09375,0.0937 -0.152344,0.0937 h -3.964844 c -0.07812,0 -0.136718,-0.0469 -0.167968,-0.10938 -0.03125,-0.0586 -0.03125,-0.13671 0.01563,-0.19531 l 5.519531,-8.41406 -5.003906,-7.71484 c -0.02734,-0.0586 -0.02734,-0.13672 0,-0.19532 0.03125,-0.0625 0.09375,-0.10937 0.167968,-0.10937 h 3.859376 c 0.0625,0 0.121093,0.0469 0.167968,0.0937 l 3.125,4.98828 3.050782,-4.98828 c 0.04687,-0.0469 0.105468,-0.0937 0.167968,-0.0937 h 3.828125 c 0.07422,0 0.136719,0.0469 0.167969,0.10937 0.02734,0.0586 0.02734,0.13672 0,0.19532 l -5.035156,7.83593 5.507812,8.25 c 0.02734,0.043 0.05859,0.0899 0.05859,0.15235 0,0.10156 -0.07422,0.19531 -0.183594,0.19531 z m 17.644532,-0.19922 c 0,0.10547 -0.09375,0.19922 -0.199219,0.19922 h -3.0625 c -0.109375,0 -0.183594,-0.0937 -0.183594,-0.19922 v -11.32031 l -2.882813,11.36719 c -0.01562,0.0898 -0.08984,0.15234 -0.183593,0.15234 h -3.1875 c -0.08984,0 -0.167969,-0.0625 -0.183594,-0.15234 l -2.851563,-11.36719 v 11.32031 c 0,0.10547 -0.08984,0.19531 -0.195312,0.19531 h -3.082031 c -0.105469,0 -0.183594,-0.0898 -0.183594,-0.19531 v -16.33984 c 0,-0.10547 0.07813,-0.19922 0.183594,-0.19922 H 81.5 c 0.08984,0 0.167969,0.0586 0.183594,0.15234 l 2.773437,10.45313 2.761719,-10.45313 c 0.01563,-0.0937 0.08984,-0.15234 0.183594,-0.15234 h 4.953125 c 0.105469,0 0.199219,0.0937 0.199219,0.19922 z m 14.882812,0 c 0,0.10547 -0.0742,0.19922 -0.18359,0.19922 H 95.726562 c -0.105468,0 -0.183593,-0.0937 -0.183593,-0.19922 v -16.20312 c 0,-0.10547 0.07813,-0.19922 0.183593,-0.19922 h 3.308594 c 0.105469,0 0.199219,0.0937 0.199219,0.19922 v 13.26953 h 8.019535 c 0.10937,0 0.18359,0.0742 0.18359,0.17968 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path256" />
+  </g>
+  <path
+     fill="#09102b"
+     d="m 10.753456,359.80895 h 58.707032 v 6.48437 H 10.753456 Z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path260" />
+  <path
+     fill="#09102b"
+     d="m 10.761268,287.53551 v 36.91406 h 58.70703 v -36.91406 z m 51.84766,32.34766 H 17.620643 c -0.835937,0 -1.523437,-0.6836 -1.523437,-1.51954 0,-0.85546 0.6875,-1.52343 1.523437,-1.52343 h 44.988285 c 0.82031,0 1.52343,0.66797 1.52343,1.52343 0,0.83594 -0.70312,1.51954 -1.52343,1.51954 z m 0,-10.65235 H 17.620643 c -0.835937,0 -1.523437,-0.68359 -1.523437,-1.51953 0,-0.85156 0.6875,-1.52344 1.523437,-1.52344 h 44.988285 c 0.82031,0 1.52343,0.67188 1.52343,1.52344 0,0.83594 -0.70312,1.51953 -1.52343,1.51953 z m 0,-10.64844 H 17.620643 c -0.835937,0 -1.523437,-0.6875 -1.523437,-1.52343 0,-0.85157 0.6875,-1.52344 1.523437,-1.52344 h 44.988285 c 0.82031,0 1.52343,0.67187 1.52343,1.52344 0,0.83593 -0.70312,1.52343 -1.52343,1.52343 z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path262" />
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g270"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(126.27432,523.15898)"
+       id="g268">
+      <g
+         id="g266">
+        <path
+           d="m 4.6875,-23.234375 4.984375,9.15625 5.046875,-9.15625 H 18.6875 L 11.8125,-11.4375 18.6875,0 H 14.484375 L 9.5,-8.75 4.40625,0 H 0.4375 l 6.921875,-11.234375 -6.921875,-12 z m 0,0"
+           id="path264" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g278"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(144.65551,523.15898)"
+       id="g276">
+      <g
+         id="g274">
+        <path
+           d="m 2.6875,0 v -23.234375 h 6.546875 l 5.1875,18.140625 5.1875,-18.140625 H 26.1875 V 0 H 22.390625 V -19.0625 H 21.875 l -5.484375,18.109375 h -3.9375 l -5.5,-18.109375 H 6.4375 V 0 Z m 0,0"
+           id="path272" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g286"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(172.73611,523.15898)"
+       id="g284">
+      <g
+         id="g282">
+        <path
+           d="M 15.703125,0 H 2.6875 v -23.234375 h 3.75 v 19.875 h 9.265625 z m 0,0"
+           id="path280" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g294"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(126.27432,557.65898)"
+       id="g292">
+      <g
+         id="g290">
+        <path
+           d="m 0.4375,-19.875 v -3.359375 H 17.40625 V -19.875 H 10.859375 V 0 H 7.0625 v -19.875 z m 0,0"
+           id="path288" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g302"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(143.36677,557.65898)"
+       id="g300">
+      <g
+         id="g298">
+        <path
+           d="M 0.671875,-16.96875 H 4.3125 l 3.59375,13.8125 H 8.8125 l 3.609375,-13.8125 h 3.65625 L 9.640625,7.296875 H 6 L 8.046875,0 H 5.125 Z m 0,0"
+           id="path296" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g310"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(159.30615,557.65898)"
+       id="g308">
+      <g
+         id="g306">
+        <path
+           d="M 2.234375,7.296875 V -16.96875 H 5.90625 v 1.0625 c 1.5625,-0.945312 3.019531,-1.421875 4.375,-1.421875 2.238281,0 3.875,0.683594 4.90625,2.046875 1.039062,1.367188 1.5625,3.664062 1.5625,6.890625 0,3.21875 -0.59375,5.484375 -1.78125,6.796875 -1.179688,1.3125 -3.117188,1.96875 -5.8125,1.96875 -0.929688,0 -2,-0.105469 -3.21875,-0.3125 v 7.234375 z m 7.40625,-21.34375 c -1.0625,0 -2.132813,0.242187 -3.203125,0.71875 l -0.5,0.234375 v 10 c 0.90625,0.1875 1.898438,0.28125 2.984375,0.28125 1.539063,0 2.601563,-0.441406 3.1875,-1.328125 0.582031,-0.882813 0.875,-2.390625 0.875,-4.515625 0,-3.59375 -1.117187,-5.390625 -3.34375,-5.390625 z m 0,0"
+           id="path304" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g318"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(176.77166,557.65898)"
+       id="g316">
+      <g
+         id="g314">
+        <path
+           d="m 14.3125,-3.046875 0.953125,-0.109375 0.0625,2.75 C 12.753906,0.113281 10.472656,0.375 8.484375,0.375 5.972656,0.375 4.164062,-0.3125 3.0625,-1.6875 1.96875,-3.070312 1.421875,-5.28125 1.421875,-8.3125 c 0,-6.007812 2.453125,-9.015625 7.359375,-9.015625 4.75,0 7.125,2.589844 7.125,7.765625 l -0.234375,2.640625 H 5.15625 c 0.019531,1.40625 0.320312,2.4375 0.90625,3.09375 0.59375,0.65625 1.691406,0.984375 3.296875,0.984375 1.601563,0 3.253906,-0.066406 4.953125,-0.203125 z m -2.03125,-6.71875 c 0,-1.675781 -0.265625,-2.847656 -0.796875,-3.515625 -0.53125,-0.664062 -1.433594,-1 -2.703125,-1 -1.261719,0 -2.183594,0.355469 -2.765625,1.0625 -0.574219,0.699219 -0.871094,1.851562 -0.890625,3.453125 z m 0,0"
+           id="path312" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g326"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(193.25366,557.65898)"
+       id="g324">
+      <g
+         id="g322">
+        <path
+           d="m 14.015625,-13.46875 c -2.679687,-0.363281 -4.617187,-0.546875 -5.8125,-0.546875 -1.199219,0 -2.03125,0.148437 -2.5,0.4375 -0.460937,0.28125 -0.6875,0.730469 -0.6875,1.34375 0,0.605469 0.253906,1.03125 0.765625,1.28125 0.507812,0.25 1.707031,0.542969 3.59375,0.875 1.894531,0.324219 3.238281,0.835937 4.03125,1.53125 0.789062,0.699219 1.1875,1.945313 1.1875,3.734375 0,1.78125 -0.574219,3.09375 -1.71875,3.9375 -1.148438,0.8359375 -2.8125,1.25 -5,1.25 -1.386719,0 -3.132812,-0.195312 -5.234375,-0.578125 L 1.59375,-0.375 1.734375,-3.453125 c 2.707031,0.355469 4.660156,0.53125 5.859375,0.53125 1.195312,0 2.050781,-0.144531 2.5625,-0.4375 0.507812,-0.289063 0.765625,-0.773437 0.765625,-1.453125 0,-0.675781 -0.246094,-1.144531 -0.734375,-1.40625 C 9.707031,-6.476562 8.546875,-6.757812 6.703125,-7.0625 4.859375,-7.375 3.503906,-7.859375 2.640625,-8.515625 c -0.855469,-0.65625 -1.28125,-1.851563 -1.28125,-3.59375 0,-1.738281 0.59375,-3.035156 1.78125,-3.890625 1.1875,-0.863281 2.707031,-1.296875 4.5625,-1.296875 1.445313,0 3.222656,0.183594 5.328125,0.546875 l 1.046875,0.203125 z m 0,0"
+           id="path320" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g334"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(208.41301,557.65898)"
+       id="g332">
+      <g
+         id="g330">
+        <path
+           d="M 0.671875,-16.96875 H 4.3125 l 3.59375,13.8125 H 8.8125 l 3.609375,-13.8125 h 3.65625 L 9.640625,7.296875 H 6 L 8.046875,0 H 5.125 Z m 0,0"
+           id="path328" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g342"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(224.35239,557.65898)"
+       id="g340">
+      <g
+         id="g338">
+        <path
+           d="m 14.015625,-13.46875 c -2.679687,-0.363281 -4.617187,-0.546875 -5.8125,-0.546875 -1.199219,0 -2.03125,0.148437 -2.5,0.4375 -0.460937,0.28125 -0.6875,0.730469 -0.6875,1.34375 0,0.605469 0.253906,1.03125 0.765625,1.28125 0.507812,0.25 1.707031,0.542969 3.59375,0.875 1.894531,0.324219 3.238281,0.835937 4.03125,1.53125 0.789062,0.699219 1.1875,1.945313 1.1875,3.734375 0,1.78125 -0.574219,3.09375 -1.71875,3.9375 -1.148438,0.8359375 -2.8125,1.25 -5,1.25 -1.386719,0 -3.132812,-0.195312 -5.234375,-0.578125 L 1.59375,-0.375 1.734375,-3.453125 c 2.707031,0.355469 4.660156,0.53125 5.859375,0.53125 1.195312,0 2.050781,-0.144531 2.5625,-0.4375 0.507812,-0.289063 0.765625,-0.773437 0.765625,-1.453125 0,-0.675781 -0.246094,-1.144531 -0.734375,-1.40625 C 9.707031,-6.476562 8.546875,-6.757812 6.703125,-7.0625 4.859375,-7.375 3.503906,-7.859375 2.640625,-8.515625 c -0.855469,-0.65625 -1.28125,-1.851563 -1.28125,-3.59375 0,-1.738281 0.59375,-3.035156 1.78125,-3.890625 1.1875,-0.863281 2.707031,-1.296875 4.5625,-1.296875 1.445313,0 3.222656,0.183594 5.328125,0.546875 l 1.046875,0.203125 z m 0,0"
+           id="path336" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g350"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(239.51175,557.65898)"
+       id="g348">
+      <g
+         id="g346">
+        <path
+           d="M 11.359375,-13.8125 H 6.6875 v 7.46875 c 0,1.375 0.097656,2.292969 0.296875,2.75 0.207031,0.449219 0.726563,0.671875 1.5625,0.671875 l 2.78125,-0.09375 L 11.5,-0.0625 C 9.988281,0.226562 8.835938,0.375 8.046875,0.375 c -1.929687,0 -3.25,-0.4375 -3.96875,-1.3125 -0.710937,-0.882812 -1.0625,-2.550781 -1.0625,-5 v -7.875 H 0.84375 v -3.15625 H 3.015625 V -21.875 H 6.6875 v 4.90625 h 4.671875 z m 0,0"
+           id="path344" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g358"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(250.90664,557.65898)"
+       id="g356">
+      <g
+         id="g354">
+        <path
+           d="m 14.3125,-3.046875 0.953125,-0.109375 0.0625,2.75 C 12.753906,0.113281 10.472656,0.375 8.484375,0.375 5.972656,0.375 4.164062,-0.3125 3.0625,-1.6875 1.96875,-3.070312 1.421875,-5.28125 1.421875,-8.3125 c 0,-6.007812 2.453125,-9.015625 7.359375,-9.015625 4.75,0 7.125,2.589844 7.125,7.765625 l -0.234375,2.640625 H 5.15625 c 0.019531,1.40625 0.320312,2.4375 0.90625,3.09375 0.59375,0.65625 1.691406,0.984375 3.296875,0.984375 1.601563,0 3.253906,-0.066406 4.953125,-0.203125 z m -2.03125,-6.71875 c 0,-1.675781 -0.265625,-2.847656 -0.796875,-3.515625 -0.53125,-0.664062 -1.433594,-1 -2.703125,-1 -1.261719,0 -2.183594,0.355469 -2.765625,1.0625 -0.574219,0.699219 -0.871094,1.851562 -0.890625,3.453125 z m 0,0"
+           id="path352" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g366"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(267.38864,557.65898)"
+       id="g364">
+      <g
+         id="g362">
+        <path
+           d="M 5.9375,0 H 2.234375 V -16.96875 H 5.90625 v 1.0625 c 1.601562,-0.945312 3.070312,-1.421875 4.40625,-1.421875 1.96875,0 3.40625,0.554687 4.3125,1.65625 2.050781,-1.101563 4.09375,-1.65625 6.125,-1.65625 2.039062,0 3.476562,0.632813 4.3125,1.890625 0.84375,1.25 1.265625,3.367188 1.265625,6.34375 V 0 H 22.65625 v -8.984375 c 0,-1.832031 -0.1875,-3.132813 -0.5625,-3.90625 -0.367188,-0.769531 -1.136719,-1.15625 -2.3125,-1.15625 -1.023438,0 -2.121094,0.230469 -3.296875,0.6875 L 15.90625,-13.125 c 0.1875,0.449219 0.28125,1.898438 0.28125,4.34375 V 0 h -3.671875 v -8.71875 c 0,-2.007812 -0.183594,-3.398438 -0.546875,-4.171875 -0.355469,-0.769531 -1.148438,-1.15625 -2.375,-1.15625 -1.125,0 -2.179688,0.230469 -3.15625,0.6875 l -0.5,0.203125 z m 0,0"
+           id="path360" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g374"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(295.06227,557.65898)"
+       id="g372">
+      <g
+         id="g370">
+        <path
+           d="m 14.015625,-13.46875 c -2.679687,-0.363281 -4.617187,-0.546875 -5.8125,-0.546875 -1.199219,0 -2.03125,0.148437 -2.5,0.4375 -0.460937,0.28125 -0.6875,0.730469 -0.6875,1.34375 0,0.605469 0.253906,1.03125 0.765625,1.28125 0.507812,0.25 1.707031,0.542969 3.59375,0.875 1.894531,0.324219 3.238281,0.835937 4.03125,1.53125 0.789062,0.699219 1.1875,1.945313 1.1875,3.734375 0,1.78125 -0.574219,3.09375 -1.71875,3.9375 -1.148438,0.8359375 -2.8125,1.25 -5,1.25 -1.386719,0 -3.132812,-0.195312 -5.234375,-0.578125 L 1.59375,-0.375 1.734375,-3.453125 c 2.707031,0.355469 4.660156,0.53125 5.859375,0.53125 1.195312,0 2.050781,-0.144531 2.5625,-0.4375 0.507812,-0.289063 0.765625,-0.773437 0.765625,-1.453125 0,-0.675781 -0.246094,-1.144531 -0.734375,-1.40625 C 9.707031,-6.476562 8.546875,-6.757812 6.703125,-7.0625 4.859375,-7.375 3.503906,-7.859375 2.640625,-8.515625 c -0.855469,-0.65625 -1.28125,-1.851563 -1.28125,-3.59375 0,-1.738281 0.59375,-3.035156 1.78125,-3.890625 1.1875,-0.863281 2.707031,-1.296875 4.5625,-1.296875 1.445313,0 3.222656,0.183594 5.328125,0.546875 l 1.046875,0.203125 z m 0,0"
+           id="path368" />
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#0baef73a1e)"
+     id="g378"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#09102b"
+       d="m 230.94531,263.10547 h -1.21875 V 254.125 c 0,-0.36719 -0.0703,-0.72266 -0.21094,-1.0625 -0.13671,-0.33594 -0.33593,-0.63672 -0.59765,-0.89844 -0.25781,-0.25781 -0.55469,-0.45703 -0.89063,-0.59765 -0.33984,-0.14063 -0.6875,-0.21094 -1.05468,-0.21094 h -2.44922 v -10.71094 c 0.004,-0.31641 -0.10547,-0.58594 -0.32032,-0.8125 L 209.78516,225.0625 c -0.23047,-0.26172 -0.51954,-0.39453 -0.86329,-0.39844 h -35.35546 c -0.14844,0 -0.29688,0.0312 -0.4375,0.0898 -0.14063,0.0586 -0.26563,0.14062 -0.3711,0.25 -0.10937,0.10546 -0.1914,0.23046 -0.25,0.375 -0.0586,0.14062 -0.0859,0.28515 -0.0859,0.4414 v 25.55078 h -2.48828 c -0.36328,0 -0.71484,0.0703 -1.05468,0.21094 -0.33594,0.14063 -0.63282,0.34375 -0.89063,0.60156 -0.25781,0.26172 -0.45703,0.5586 -0.59766,0.89844 -0.14062,0.33984 -0.21093,0.69141 -0.21093,1.05859 v 12.70313 h -0.44141 c -0.36328,0 -0.71484,0.0703 -1.05078,0.21094 -0.33984,0.14062 -0.63672,0.34375 -0.89453,0.60156 -0.25781,0.26172 -0.45703,0.55859 -0.59766,0.89844 -0.13672,0.33984 -0.20703,0.6914 -0.20703,1.05859 0,0 0,0.10156 0,0.16016 l 3.17578,23.74218 c 0.0117,0.35938 0.0898,0.70313 0.23438,1.03125 0.14843,0.32422 0.34765,0.61329 0.60547,0.86329 0.25781,0.25 0.55078,0.4414 0.88281,0.57421 0.32812,0.13282 0.67187,0.19922 1.02734,0.19922 h 57.07813 c 0.35547,0 0.69922,-0.0664 1.02734,-0.19922 0.33203,-0.13281 0.625,-0.32421 0.87891,-0.57031 0.25781,-0.25 0.46093,-0.53515 0.60547,-0.86328 0.14453,-0.32422 0.22656,-0.66797 0.24218,-1.02344 l 3.95313,-27.5039 c 0.004,-0.0547 0.004,-0.10938 0,-0.16407 0,-0.36718 -0.0742,-0.71875 -0.21485,-1.05468 -0.14062,-0.33985 -0.33984,-0.63672 -0.59765,-0.89453 -0.25781,-0.25782 -0.55469,-0.45704 -0.89063,-0.59375 -0.33593,-0.14063 -0.6875,-0.21094 -1.05078,-0.21094 z m -61.48828,3.73828 V 254.125 c 0.004,-0.12109 0.0469,-0.22656 0.13281,-0.3125 0.082,-0.0859 0.1875,-0.12891 0.3086,-0.13281 h 2.48437 v 13.16406 z m 33.60938,-3.19141 -1.95704,3.19141 h -26.39453 v -39.87109 h 33.08594 v 13.67187 c 0.0117,0.30859 0.12109,0.56641 0.33984,0.78516 0.21485,0.21484 0.47657,0.32422 0.78125,0.33203 h 13.28907 v 21.34375 h -18.12891 c -0.42578,0 -0.75391,0.17969 -0.98047,0.54687 z m 21.45703,-0.54687 v -9.42578 h 2.48437 c 0.1211,0.004 0.22656,0.0469 0.3125,0.13281 0.082,0.0859 0.12891,0.19141 0.12891,0.3125 v 8.98047 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path376" />
+  </g>
+  <path
+     fill="#09102b"
+     d="m 138.5308,35.426124 h 17.95313 c 0.15234,0 0.29687,-0.0312 0.4375,-0.0898 0.14062,-0.0586 0.26562,-0.14062 0.375,-0.25 0.10546,-0.10547 0.1875,-0.23047 0.24609,-0.37109 0.0586,-0.14453 0.0898,-0.28907 0.0898,-0.44532 0,-0.15234 -0.0312,-0.29687 -0.0898,-0.4414 -0.0586,-0.14063 -0.14063,-0.26563 -0.24609,-0.3711 -0.10938,-0.10937 -0.23438,-0.1914 -0.375,-0.25 -0.14063,-0.0586 -0.28516,-0.0898 -0.4375,-0.0898 H 138.5308 c -0.15234,0 -0.29687,0.0312 -0.4375,0.0898 -0.14062,0.0586 -0.26562,0.14063 -0.37109,0.25 -0.10938,0.10547 -0.19141,0.23047 -0.25,0.3711 -0.0586,0.14453 -0.0859,0.28906 -0.0859,0.4414 0,0.15625 0.0273,0.30079 0.0859,0.44532 0.0586,0.14062 0.14062,0.26562 0.25,0.37109 0.10547,0.10938 0.23047,0.19141 0.37109,0.25 0.14063,0.0586 0.28516,0.0898 0.4375,0.0898 z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path380" />
+  <path
+     fill="#09102b"
+     d="m 144.88236,56.051124 h -6.35156 c -0.15234,0 -0.29687,0.0274 -0.4375,0.0859 -0.14062,0.0586 -0.26562,0.14063 -0.37109,0.25 -0.10938,0.10938 -0.19141,0.23438 -0.25,0.375 -0.0586,0.14063 -0.0859,0.28906 -0.0859,0.44141 0,0.15234 0.0273,0.30078 0.0859,0.4414 0.0586,0.14063 0.14062,0.26563 0.25,0.375 0.10547,0.10938 0.23047,0.19141 0.37109,0.25 0.14063,0.0586 0.28516,0.0859 0.4375,0.0859 h 6.35156 c 0.15235,0 0.30078,-0.0273 0.44141,-0.0859 0.14062,-0.0586 0.26172,-0.14062 0.37109,-0.25 0.10547,-0.10937 0.19141,-0.23437 0.25,-0.375 0.0547,-0.14062 0.0859,-0.28906 0.0859,-0.4414 0,-0.15235 -0.0312,-0.30078 -0.0859,-0.44141 -0.0586,-0.14062 -0.14453,-0.26562 -0.25,-0.375 -0.10937,-0.10937 -0.23047,-0.1914 -0.37109,-0.25 -0.14063,-0.0586 -0.28906,-0.0859 -0.44141,-0.0859 z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path382" />
+  <path
+     fill="#09102b"
+     d="m 158.89799,56.051124 h -8.54688 c -0.14843,0 -0.29687,0.0274 -0.4375,0.0859 -0.14062,0.0586 -0.26562,0.14063 -0.37109,0.25 -0.10938,0.10938 -0.19141,0.23438 -0.25,0.375 -0.0586,0.14063 -0.0859,0.28906 -0.0859,0.44141 0,0.15234 0.0273,0.30078 0.0859,0.4414 0.0586,0.14063 0.14062,0.26563 0.25,0.375 0.10547,0.10938 0.23047,0.19141 0.37109,0.25 0.14063,0.0586 0.28907,0.0859 0.4375,0.0859 h 8.54688 c 0.15234,0 0.29687,-0.0273 0.4375,-0.0859 0.14062,-0.0586 0.26562,-0.14062 0.375,-0.25 0.10547,-0.10937 0.1875,-0.23437 0.24609,-0.375 0.0586,-0.14062 0.0898,-0.28906 0.0898,-0.4414 0,-0.15235 -0.0312,-0.30078 -0.0898,-0.44141 -0.0586,-0.14062 -0.14062,-0.26562 -0.24609,-0.375 -0.10938,-0.10937 -0.23438,-0.1914 -0.375,-0.25 -0.14063,-0.0586 -0.28516,-0.0859 -0.4375,-0.0859 z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path384" />
+  <path
+     fill="#09102b"
+     d="m 138.5308,40.613624 h 20.30078 c 0.15235,0 0.30078,-0.0273 0.44141,-0.0859 0.14062,-0.0586 0.26562,-0.14453 0.37109,-0.25 0.10938,-0.10938 0.19141,-0.23438 0.25,-0.375 0.0586,-0.14063 0.0859,-0.28907 0.0859,-0.44141 0,-0.15625 -0.0273,-0.30078 -0.0859,-0.44141 -0.0586,-0.14453 -0.14062,-0.26953 -0.25,-0.375 -0.10547,-0.10937 -0.23047,-0.1914 -0.37109,-0.25 -0.14063,-0.0586 -0.28906,-0.0898 -0.44141,-0.0898 H 138.5308 c -0.15234,0 -0.29687,0.0312 -0.4375,0.0898 -0.14062,0.0586 -0.26562,0.14063 -0.37109,0.25 -0.10938,0.10547 -0.19141,0.23047 -0.25,0.375 -0.0586,0.14063 -0.0859,0.28516 -0.0859,0.44141 0,0.15234 0.0273,0.30078 0.0859,0.44141 0.0586,0.14062 0.14062,0.26562 0.25,0.375 0.10547,0.10547 0.23047,0.1914 0.37109,0.25 0.14063,0.0586 0.28516,0.0859 0.4375,0.0859 z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path386" />
+  <path
+     fill="#09102b"
+     d="M 166.35111,50.269874 H 138.5308 c -0.15234,0 -0.29687,0.0312 -0.4375,0.0898 -0.14062,0.0586 -0.26562,0.14062 -0.37109,0.25 -0.10938,0.10547 -0.19141,0.23047 -0.25,0.375 -0.0586,0.14062 -0.0859,0.28515 -0.0859,0.4414 0,0.15235 0.0273,0.29688 0.0859,0.44141 0.0586,0.14063 0.14062,0.26563 0.25,0.37109 0.10547,0.10938 0.23047,0.19532 0.37109,0.25391 0.14063,0.0586 0.28516,0.0859 0.4375,0.0859 h 27.82031 c 0.15235,0 0.29688,-0.0273 0.4375,-0.0859 0.14063,-0.0586 0.26563,-0.14453 0.3711,-0.25391 0.10937,-0.10546 0.1914,-0.23046 0.25,-0.37109 0.0586,-0.14453 0.0859,-0.28906 0.0859,-0.44141 0,-0.15625 -0.0273,-0.30078 -0.0859,-0.4414 -0.0586,-0.14453 -0.14063,-0.26953 -0.25,-0.375 -0.10547,-0.10938 -0.23047,-0.19141 -0.3711,-0.25 -0.14062,-0.0586 -0.28515,-0.0898 -0.4375,-0.0898 z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path388" />
+  <path
+     fill="#09102b"
+     d="m 172.45268,44.351914 h -33.95704 c -0.15234,0 -0.30078,0.0312 -0.4414,0.0898 -0.14063,0.0586 -0.26172,0.14062 -0.3711,0.25 -0.10937,0.10547 -0.1914,0.23047 -0.25,0.375 -0.0586,0.14062 -0.0859,0.28516 -0.0859,0.44141 0,0.15234 0.0273,0.30078 0.0859,0.4414 0.0586,0.14063 0.14063,0.26563 0.25,0.375 0.10938,0.10547 0.23047,0.19141 0.3711,0.25 0.14062,0.0586 0.28906,0.0859 0.4414,0.0859 h 33.95704 c 0.15234,0 0.29687,-0.0273 0.4375,-0.0859 0.14062,-0.0586 0.26562,-0.14453 0.375,-0.25 0.10546,-0.10937 0.1875,-0.23437 0.24609,-0.375 0.0586,-0.14062 0.0898,-0.28906 0.0898,-0.4414 0,-0.15625 -0.0312,-0.30079 -0.0898,-0.44141 -0.0586,-0.14453 -0.14063,-0.26953 -0.24609,-0.375 -0.10938,-0.10938 -0.23438,-0.19141 -0.375,-0.25 -0.14063,-0.0586 -0.28516,-0.0898 -0.4375,-0.0898 z m 0,0"
+     fill-opacity="1"
+     fill-rule="nonzero"
+     id="path390" />
+  <g
+     clip-path="url(#1f4a27800a)"
+     id="g398"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       mask="url(#e94e818b4b)"
+       id="g396">
+      <g
+         transform="matrix(0.196004,0,0,0.194118,62.344152,227.08093)"
+         id="g394">
+        <image
+           x="0"
+           y="0"
+           width="463"
+           xlink:href="data:image/png;base64,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"
+           height="340"
+           preserveAspectRatio="xMidYMid"
+           id="image392" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g406"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(62.344152,330.62669)"
+       id="g404">
+      <g
+         id="g402">
+        <path
+           d="M 11.78125,0.390625 C 8.039062,0.390625 5.4375,-0.613281 3.96875,-2.625 2.5,-4.632812 1.765625,-7.8125 1.765625,-12.15625 1.765625,-16.5 2.507812,-19.722656 4,-21.828125 5.5,-23.941406 8.09375,-25 11.78125,-25 c 3.6875,0 6.269531,1.046875 7.75,3.140625 1.488281,2.09375 2.234375,5.324219 2.234375,9.6875 0,2.875 -0.308594,5.199219 -0.921875,6.96875 -0.605469,1.773437 -1.601562,3.121094 -2.984375,4.046875 l 3.015625,4.859375 -3.703125,1.71875 -3.203125,-5.25 c -0.449219,0.144531 -1.179688,0.21875 -2.1875,0.21875 z M 7.109375,-5.1875 c 0.8125,1.398438 2.367187,2.09375 4.671875,2.09375 2.300781,0 3.851562,-0.6875 4.65625,-2.0625 0.800781,-1.375 1.203125,-3.703125 1.203125,-6.984375 0,-3.28125 -0.417969,-5.660156 -1.25,-7.140625 -0.824219,-1.488281 -2.359375,-2.234375 -4.609375,-2.234375 -2.25,0 -3.796875,0.746094 -4.640625,2.234375 -0.835937,1.480469 -1.25,3.851562 -1.25,7.109375 0,3.25 0.40625,5.578125 1.21875,6.984375 z m 0,0"
+           id="path400" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g414"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(85.1083,330.62669)"
+       id="g412">
+      <g
+         id="g410">
+        <path
+           d="M 12.03125,-14.625 H 7.078125 v 7.90625 c 0,1.460938 0.101563,2.429688 0.3125,2.90625 0.21875,0.480469 0.769531,0.71875 1.65625,0.71875 L 12,-3.203125 l 0.171875,3.125 c -1.605469,0.3125 -2.824219,0.46875 -3.65625,0.46875 -2.042969,0 -3.4375,-0.4609375 -4.1875,-1.390625 -0.75,-0.9375 -1.125,-2.695312 -1.125,-5.28125 V -14.625 h -2.3125 v -3.328125 h 2.3125 v -5.21875 h 3.875 v 5.21875 h 4.953125 z m 0,0"
+           id="path408" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g420"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(97.172393,330.62669)"
+       id="g418">
+      <g
+         id="g416" />
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g428"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(104.28144,330.62669)"
+       id="g426">
+      <g
+         id="g424">
+        <path
+           d="m 17.453125,0 v -10.640625 h -10.625 V 0 H 2.84375 V -24.609375 H 6.828125 V -14.125 h 10.625 v -10.484375 h 4.03125 V 0 Z m 0,0"
+           id="path422" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g436"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(127.7637,330.62669)"
+       id="g434">
+      <g
+         id="g432">
+        <path
+           d="m 15.15625,-3.234375 1.015625,-0.109375 0.0625,2.90625 c -2.730469,0.550781 -5.148437,0.828125 -7.25,0.828125 -2.65625,0 -4.570313,-0.726563 -5.734375,-2.1875 -1.15625,-1.457031 -1.734375,-3.789063 -1.734375,-7 0,-6.375 2.59375,-9.5625 7.78125,-9.5625 5.03125,0 7.546875,2.746094 7.546875,8.234375 l -0.25,2.796875 H 5.453125 c 0.03125,1.492187 0.351563,2.585937 0.96875,3.28125 0.625,0.6875 1.785156,1.03125 3.484375,1.03125 1.707031,0 3.457031,-0.070313 5.25,-0.21875 z M 13,-10.34375 c 0,-1.769531 -0.28125,-3.007812 -0.84375,-3.71875 -0.5625,-0.707031 -1.515625,-1.0625 -2.859375,-1.0625 -1.335937,0 -2.308594,0.375 -2.921875,1.125 -0.617188,0.742188 -0.933594,1.960938 -0.953125,3.65625 z m 0,0"
+           id="path430" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g444"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(145.21372,330.62669)"
+       id="g442">
+      <g
+         id="g440">
+        <path
+           d="m 15.65625,-12.421875 v 8.1875 c 0.03125,0.523437 0.171875,0.914063 0.421875,1.171875 0.25,0.25 0.640625,0.40625 1.171875,0.46875 l -0.109375,2.984375 c -2.0625,0 -3.65625,-0.4414062 -4.78125,-1.328125 -1.917969,0.8867188 -3.84375,1.328125 -5.78125,1.328125 -3.574219,0 -5.359375,-1.898437 -5.359375,-5.703125 0,-1.820312 0.484375,-3.140625 1.453125,-3.953125 0.96875,-0.8125 2.460937,-1.300781 4.484375,-1.46875 l 4.625,-0.40625 v -1.28125 c 0,-0.957031 -0.210938,-1.628906 -0.625,-2.015625 -0.417969,-0.382812 -1.039062,-0.578125 -1.859375,-0.578125 -1.53125,0 -3.445313,0.09375 -5.734375,0.28125 l -1.15625,0.07813 -0.140625,-2.765625 c 2.601563,-0.625 5,-0.9375 7.1875,-0.9375 2.195313,0 3.78125,0.476563 4.75,1.421875 0.96875,0.949219 1.453125,2.453125 1.453125,4.515625 z M 7.609375,-7.96875 c -1.648437,0.136719 -2.46875,1.03125 -2.46875,2.6875 0,1.65625 0.726563,2.484375 2.1875,2.484375 1.195313,0 2.46875,-0.191406 3.8125,-0.578125 L 11.78125,-3.59375 V -8.375 Z m 0,0"
+           id="path438" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g452"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(162.62784,330.62669)"
+       id="g450">
+      <g
+         id="g448">
+        <path
+           d="M 17.03125,-25.4375 V 0 h -3.890625 v -0.9375 c -1.742187,0.8867188 -3.34375,1.328125 -4.8125,1.328125 -2.34375,0 -4.0625,-0.703125 -5.15625,-2.109375 -1.085937,-1.414062 -1.625,-3.785156 -1.625,-7.109375 0,-3.332031 0.601563,-5.753906 1.8125,-7.265625 1.207031,-1.507812 3.09375,-2.265625 5.65625,-2.265625 0.863281,0 2.226563,0.15625 4.09375,0.46875 V -25.4375 Z M 12.5,-3.734375 l 0.609375,-0.25 V -14.625 c -1.4375,-0.238281 -2.765625,-0.359375 -3.984375,-0.359375 -2.417969,0 -3.625,2.015625 -3.625,6.046875 0,2.199219 0.28125,3.726562 0.84375,4.578125 0.5625,0.84375 1.453125,1.265625 2.671875,1.265625 1.21875,0 2.378906,-0.210938 3.484375,-0.640625 z m 0,0"
+           id="path446" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g460"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(181.22687,330.62669)"
+       id="g458">
+      <g
+         id="g456">
+        <path
+           d="m 15.15625,-3.234375 1.015625,-0.109375 0.0625,2.90625 c -2.730469,0.550781 -5.148437,0.828125 -7.25,0.828125 -2.65625,0 -4.570313,-0.726563 -5.734375,-2.1875 -1.15625,-1.457031 -1.734375,-3.789063 -1.734375,-7 0,-6.375 2.59375,-9.5625 7.78125,-9.5625 5.03125,0 7.546875,2.746094 7.546875,8.234375 l -0.25,2.796875 H 5.453125 c 0.03125,1.492187 0.351563,2.585937 0.96875,3.28125 0.625,0.6875 1.785156,1.03125 3.484375,1.03125 1.707031,0 3.457031,-0.070313 5.25,-0.21875 z M 13,-10.34375 c 0,-1.769531 -0.28125,-3.007812 -0.84375,-3.71875 -0.5625,-0.707031 -1.515625,-1.0625 -2.859375,-1.0625 -1.335937,0 -2.308594,0.375 -2.921875,1.125 -0.617188,0.742188 -0.933594,1.960938 -0.953125,3.65625 z m 0,0"
+           id="path454" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g468"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(198.6769,330.62669)"
+       id="g466">
+      <g
+         id="g464">
+        <path
+           d="M 2.375,0 V -17.953125 H 6.25 v 2.140625 c 2.03125,-1.3125 4.066406,-2.160156 6.109375,-2.546875 v 3.921875 c -2.0625,0.40625 -3.824219,0.933594 -5.28125,1.578125 L 6.28125,-12.53125 V 0 Z m 0,0"
+           id="path462" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g476"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(210.84872,330.62669)"
+       id="g474">
+      <g
+         id="g472">
+        <path
+           d="m 14.828125,-14.265625 c -2.824219,-0.375 -4.871094,-0.5625 -6.140625,-0.5625 -1.261719,0 -2.140625,0.152344 -2.640625,0.453125 -0.492187,0.292969 -0.734375,0.761719 -0.734375,1.40625 0,0.648438 0.269531,1.105469 0.8125,1.375 0.539062,0.261719 1.8125,0.5625 3.8125,0.90625 2,0.34375 3.414062,0.890625 4.25,1.640625 0.84375,0.742187 1.265625,2.058594 1.265625,3.953125 0,1.886719 -0.609375,3.273438 -1.828125,4.15625 -1.210938,0.8867188 -2.976562,1.328125 -5.296875,1.328125 -1.460937,0 -3.304687,-0.203125 -5.53125,-0.609375 L 1.6875,-0.390625 1.828125,-3.65625 c 2.875,0.375 4.945313,0.5625 6.21875,0.5625 1.269531,0 2.171875,-0.148438 2.703125,-0.453125 0.539062,-0.3125 0.8125,-0.828125 0.8125,-1.546875 0,-0.71875 -0.261719,-1.210938 -0.78125,-1.484375 -0.511719,-0.28125 -1.742188,-0.582031 -3.6875,-0.90625 -1.949219,-0.320313 -3.382812,-0.832031 -4.296875,-1.53125 -0.90625,-0.695313 -1.359375,-1.96875 -1.359375,-3.8125 0,-1.84375 0.625,-3.21875 1.875,-4.125 1.257812,-0.90625 2.875,-1.359375 4.84375,-1.359375 1.53125,0 3.410156,0.1875 5.640625,0.5625 l 1.109375,0.21875 z m 0,0"
+           id="path470" />
+      </g>
+    </g>
+  </g>
+  <g
+     mask="url(#8f2a27f6f4)"
+     id="g482"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="matrix(0.198482,0,0,0.198482,536.61425,471.98102)"
+       id="g480">
+      <image
+         x="0"
+         y="0"
+         width="461"
+         xlink:href="data:image/png;base64,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"
+         height="461"
+         preserveAspectRatio="xMidYMid"
+         id="image478" />
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g490"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(633.94891,514.05933)"
+       id="g488">
+      <g
+         id="g486">
+        <path
+           d="M 0.8125,-23.234375 H 4.78125 L 8.109375,-3.25 H 8.8125 l 4.421875,-19.921875 h 4.40625 L 22.046875,-3.25 h 0.75 L 26.125,-23.234375 h 3.96875 L 25.515625,0 H 19.4375 l -4,-18.625 L 11.46875,0 H 5.359375 Z m 0,0"
+           id="path484" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g498"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(664.09827,514.05933)"
+       id="g496">
+      <g
+         id="g494">
+        <path
+           d="M 5.9375,0 H 2.234375 V -24.015625 H 5.9375 v 7.9375 c 1.675781,-0.832031 3.222656,-1.25 4.640625,-1.25 2.257813,0 3.800781,0.640625 4.625,1.921875 0.832031,1.273438 1.25,3.375 1.25,6.3125 V 0 H 12.75 v -8.984375 c 0,-1.832031 -0.195312,-3.132813 -0.578125,-3.90625 -0.386719,-0.769531 -1.199219,-1.15625 -2.4375,-1.15625 -1.085937,0 -2.167969,0.183594 -3.25,0.546875 L 5.9375,-13.296875 Z m 0,0"
+           id="path492" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g506"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(681.869,514.05933)"
+       id="g504">
+      <g
+         id="g502">
+        <path
+           d="m 14.3125,-3.046875 0.953125,-0.109375 0.0625,2.75 C 12.753906,0.113281 10.472656,0.375 8.484375,0.375 5.972656,0.375 4.164062,-0.3125 3.0625,-1.6875 1.96875,-3.070312 1.421875,-5.28125 1.421875,-8.3125 c 0,-6.007812 2.453125,-9.015625 7.359375,-9.015625 4.75,0 7.125,2.589844 7.125,7.765625 l -0.234375,2.640625 H 5.15625 c 0.019531,1.40625 0.320312,2.4375 0.90625,3.09375 0.59375,0.65625 1.691406,0.984375 3.296875,0.984375 1.601563,0 3.253906,-0.066406 4.953125,-0.203125 z m -2.03125,-6.71875 c 0,-1.675781 -0.265625,-2.847656 -0.796875,-3.515625 -0.53125,-0.664062 -1.433594,-1 -2.703125,-1 -1.261719,0 -2.183594,0.355469 -2.765625,1.0625 -0.574219,0.699219 -0.871094,1.851562 -0.890625,3.453125 z m 0,0"
+           id="path500" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g514"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(698.351,514.05933)"
+       id="g512">
+      <g
+         id="g510">
+        <path
+           d="m 14.3125,-3.046875 0.953125,-0.109375 0.0625,2.75 C 12.753906,0.113281 10.472656,0.375 8.484375,0.375 5.972656,0.375 4.164062,-0.3125 3.0625,-1.6875 1.96875,-3.070312 1.421875,-5.28125 1.421875,-8.3125 c 0,-6.007812 2.453125,-9.015625 7.359375,-9.015625 4.75,0 7.125,2.589844 7.125,7.765625 l -0.234375,2.640625 H 5.15625 c 0.019531,1.40625 0.320312,2.4375 0.90625,3.09375 0.59375,0.65625 1.691406,0.984375 3.296875,0.984375 1.601563,0 3.253906,-0.066406 4.953125,-0.203125 z m -2.03125,-6.71875 c 0,-1.675781 -0.265625,-2.847656 -0.796875,-3.515625 -0.53125,-0.664062 -1.433594,-1 -2.703125,-1 -1.261719,0 -2.183594,0.355469 -2.765625,1.0625 -0.574219,0.699219 -0.871094,1.851562 -0.890625,3.453125 z m 0,0"
+           id="path508" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g522"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(714.833,514.05933)"
+       id="g520">
+      <g
+         id="g518">
+        <path
+           d="M 2.4375,0 V -24.015625 H 6.140625 V 0 Z m 0,0"
+           id="path516" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g530"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(633.94891,548.55933)"
+       id="g528">
+      <g
+         id="g526">
+        <path
+           d="m 11.1875,-7.21875 h -4.75 V 0 h -3.75 v -23.234375 h 8.5 c 5.269531,0 7.90625,2.601563 7.90625,7.796875 0,2.667969 -0.664062,4.703125 -1.984375,6.109375 -1.324219,1.40625 -3.296875,2.109375 -5.921875,2.109375 z m -4.75,-3.265625 h 4.71875 c 2.71875,0 4.078125,-1.648437 4.078125,-4.953125 0,-1.582031 -0.328125,-2.734375 -0.984375,-3.453125 -0.65625,-0.726563 -1.6875,-1.09375 -3.09375,-1.09375 H 6.4375 Z m 0,0"
+           id="path524" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g538"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(653.24578,548.55933)"
+       id="g536">
+      <g
+         id="g534">
+        <path
+           d="M 14.796875,-11.734375 V -4 c 0.01953,0.5 0.144531,0.871094 0.375,1.109375 0.238281,0.230469 0.609375,0.382813 1.109375,0.453125 L 16.1875,0.375 c -1.949219,0 -3.453125,-0.4140625 -4.515625,-1.25 -1.8125,0.8359375 -3.636719,1.25 -5.46875,1.25 -3.367187,0 -5.046875,-1.796875 -5.046875,-5.390625 0,-1.71875 0.457031,-2.960937 1.375,-3.734375 0.914062,-0.769531 2.320312,-1.234375 4.21875,-1.390625 l 4.375,-0.375 v -1.21875 c 0,-0.90625 -0.199219,-1.535156 -0.59375,-1.890625 -0.398438,-0.363281 -0.980469,-0.546875 -1.75,-0.546875 -1.449219,0 -3.257812,0.08984 -5.421875,0.265625 l -1.09375,0.0625 -0.125,-2.609375 c 2.457031,-0.582031 4.722656,-0.875 6.796875,-0.875 2.070312,0 3.566406,0.449219 4.484375,1.34375 0.914063,0.886719 1.375,2.304687 1.375,4.25 z M 7.1875,-7.53125 c -1.5625,0.136719 -2.34375,0.984375 -2.34375,2.546875 0,1.5625 0.691406,2.34375 2.078125,2.34375 1.125,0 2.320313,-0.179687 3.59375,-0.546875 L 11.125,-3.390625 V -7.90625 Z m 0,0"
+           id="path532" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g546"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(669.69387,548.55933)"
+       id="g544">
+      <g
+         id="g542">
+        <path
+           d="m 8.578125,-17.328125 c 1.195313,0 2.613281,0.15625 4.25,0.46875 l 0.84375,0.171875 -0.140625,2.921875 c -1.78125,-0.1875 -3.105469,-0.28125 -3.96875,-0.28125 -1.71875,0 -2.875,0.386719 -3.46875,1.15625 -0.585938,0.773437 -0.875,2.21875 -0.875,4.34375 0,2.125 0.28125,3.59375 0.84375,4.40625 0.570312,0.8125 1.75,1.21875 3.53125,1.21875 L 13.5625,-3.1875 13.671875,-0.234375 C 11.390625,0.171875 9.671875,0.375 8.515625,0.375 5.929688,0.375 4.113281,-0.316406 3.0625,-1.703125 2.019531,-3.097656 1.5,-5.378906 1.5,-8.546875 c 0,-3.164063 0.550781,-5.421875 1.65625,-6.765625 1.101562,-1.34375 2.910156,-2.015625 5.421875,-2.015625 z m 0,0"
+           id="path540" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g554"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(683.93754,548.55933)"
+       id="g552">
+      <g
+         id="g550">
+        <path
+           d="M 5.9375,0 H 2.234375 V -24.015625 H 5.9375 v 13.875 l 2.109375,-0.203125 4,-6.625 H 16.1875 L 11.296875,-9.015625 16.453125,0 H 12.28125 L 8.140625,-7.15625 5.9375,-6.921875 Z m 0,0"
+           id="path548" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g562"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(700.11432,548.55933)"
+       id="g560">
+      <g
+         id="g558">
+        <path
+           d="M 14.796875,-11.734375 V -4 c 0.01953,0.5 0.144531,0.871094 0.375,1.109375 0.238281,0.230469 0.609375,0.382813 1.109375,0.453125 L 16.1875,0.375 c -1.949219,0 -3.453125,-0.4140625 -4.515625,-1.25 -1.8125,0.8359375 -3.636719,1.25 -5.46875,1.25 -3.367187,0 -5.046875,-1.796875 -5.046875,-5.390625 0,-1.71875 0.457031,-2.960937 1.375,-3.734375 0.914062,-0.769531 2.320312,-1.234375 4.21875,-1.390625 l 4.375,-0.375 v -1.21875 c 0,-0.90625 -0.199219,-1.535156 -0.59375,-1.890625 -0.398438,-0.363281 -0.980469,-0.546875 -1.75,-0.546875 -1.449219,0 -3.257812,0.08984 -5.421875,0.265625 l -1.09375,0.0625 -0.125,-2.609375 c 2.457031,-0.582031 4.722656,-0.875 6.796875,-0.875 2.070312,0 3.566406,0.449219 4.484375,1.34375 0.914063,0.886719 1.375,2.304687 1.375,4.25 z M 7.1875,-7.53125 c -1.5625,0.136719 -2.34375,0.984375 -2.34375,2.546875 0,1.5625 0.691406,2.34375 2.078125,2.34375 1.125,0 2.320313,-0.179687 3.59375,-0.546875 L 11.125,-3.390625 V -7.90625 Z m 0,0"
+           id="path556" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g570"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(716.56241,548.55933)"
+       id="g568">
+      <g
+         id="g566">
+        <path
+           d="m 17.0625,2.3125 c 0,3.707031 -2.683594,5.5625 -8.046875,5.5625 C 6.441406,7.875 4.53125,7.519531 3.28125,6.8125 2.039062,6.113281 1.421875,4.835938 1.421875,2.984375 1.421875,2.148438 1.625,1.429688 2.03125,0.828125 2.4375,0.234375 3.09375,-0.414062 4,-1.125 3.257812,-1.613281 2.890625,-2.4375 2.890625,-3.59375 c 0,-0.457031 0.300781,-1.191406 0.90625,-2.203125 L 4.109375,-6.3125 C 2.472656,-7.28125 1.65625,-8.972656 1.65625,-11.390625 c 0,-2.039063 0.609375,-3.535156 1.828125,-4.484375 1.226563,-0.945312 2.882813,-1.421875 4.96875,-1.421875 0.988281,0 1.96875,0.109375 2.9375,0.328125 L 11.90625,-16.859375 17.171875,-17 v 2.984375 l -2.828125,-0.15625 c 0.613281,0.792969 0.921875,1.71875 0.921875,2.78125 0,2.210937 -0.5625,3.742187 -1.6875,4.59375 -1.117187,0.84375 -2.859375,1.265625 -5.234375,1.265625 -0.585938,0 -1.078125,-0.046875 -1.484375,-0.140625 C 6.535156,-4.898438 6.375,-4.300781 6.375,-3.875 c 0,0.417969 0.207031,0.703125 0.625,0.859375 0.414062,0.15625 1.429688,0.246094 3.046875,0.265625 2.6875,0.023438 4.523437,0.386719 5.515625,1.09375 1,0.699219 1.5,2.019531 1.5,3.96875 z M 5.046875,2.640625 c 0,0.789063 0.316406,1.351563 0.953125,1.6875 0.632812,0.34375 1.722656,0.515625 3.265625,0.515625 2.726563,0 4.09375,-0.777344 4.09375,-2.328125 0,-0.886719 -0.246094,-1.449219 -0.734375,-1.6875 C 12.144531,0.585938 11.179688,0.457031 9.734375,0.4375 L 6.40625,0.234375 C 5.914062,0.640625 5.566406,1.019531 5.359375,1.375 5.148438,1.726562 5.046875,2.148438 5.046875,2.640625 Z m 0.28125,-14.03125 c 0,1.03125 0.242187,1.792969 0.734375,2.28125 0.5,0.492187 1.300781,0.734375 2.40625,0.734375 1.113281,0 1.910156,-0.242188 2.390625,-0.734375 0.488281,-0.488281 0.734375,-1.25 0.734375,-2.28125 0,-1.039063 -0.25,-1.804687 -0.75,-2.296875 -0.492188,-0.488281 -1.289062,-0.734375 -2.390625,-0.734375 -2.085937,0 -3.125,1.011719 -3.125,3.03125 z m 0,0"
+           id="path564" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g578"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(733.62094,548.55933)"
+       id="g576">
+      <g
+         id="g574">
+        <path
+           d="m 14.3125,-3.046875 0.953125,-0.109375 0.0625,2.75 C 12.753906,0.113281 10.472656,0.375 8.484375,0.375 5.972656,0.375 4.164062,-0.3125 3.0625,-1.6875 1.96875,-3.070312 1.421875,-5.28125 1.421875,-8.3125 c 0,-6.007812 2.453125,-9.015625 7.359375,-9.015625 4.75,0 7.125,2.589844 7.125,7.765625 l -0.234375,2.640625 H 5.15625 c 0.019531,1.40625 0.320312,2.4375 0.90625,3.09375 0.59375,0.65625 1.691406,0.984375 3.296875,0.984375 1.601563,0 3.253906,-0.066406 4.953125,-0.203125 z m -2.03125,-6.71875 c 0,-1.675781 -0.265625,-2.847656 -0.796875,-3.515625 -0.53125,-0.664062 -1.433594,-1 -2.703125,-1 -1.261719,0 -2.183594,0.355469 -2.765625,1.0625 -0.574219,0.699219 -0.871094,1.851562 -0.890625,3.453125 z m 0,0"
+           id="path572" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#000000"
+     fill-opacity="1"
+     id="g586"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(750.10294,548.55933)"
+       id="g584">
+      <g
+         id="g582">
+        <path
+           d="m 14.015625,-13.46875 c -2.679687,-0.363281 -4.617187,-0.546875 -5.8125,-0.546875 -1.199219,0 -2.03125,0.148437 -2.5,0.4375 -0.460937,0.28125 -0.6875,0.730469 -0.6875,1.34375 0,0.605469 0.253906,1.03125 0.765625,1.28125 0.507812,0.25 1.707031,0.542969 3.59375,0.875 1.894531,0.324219 3.238281,0.835937 4.03125,1.53125 0.789062,0.699219 1.1875,1.945313 1.1875,3.734375 0,1.78125 -0.574219,3.09375 -1.71875,3.9375 -1.148438,0.8359375 -2.8125,1.25 -5,1.25 -1.386719,0 -3.132812,-0.195312 -5.234375,-0.578125 L 1.59375,-0.375 1.734375,-3.453125 c 2.707031,0.355469 4.660156,0.53125 5.859375,0.53125 1.195312,0 2.050781,-0.144531 2.5625,-0.4375 0.507812,-0.289063 0.765625,-0.773437 0.765625,-1.453125 0,-0.675781 -0.246094,-1.144531 -0.734375,-1.40625 C 9.707031,-6.476562 8.546875,-6.757812 6.703125,-7.0625 4.859375,-7.375 3.503906,-7.859375 2.640625,-8.515625 c -0.855469,-0.65625 -1.28125,-1.851563 -1.28125,-3.59375 0,-1.738281 0.59375,-3.035156 1.78125,-3.890625 1.1875,-0.863281 2.707031,-1.296875 4.5625,-1.296875 1.445313,0 3.222656,0.183594 5.328125,0.546875 l 1.046875,0.203125 z m 0,0"
+           id="path580" />
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#9cd47c7ee3)"
+     id="g596"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       clip-path="url(#69785d3302)"
+       id="g594">
+      <g
+         clip-path="url(#9c0953b9a2)"
+         id="g592">
+        <g
+           clip-path="url(#8e32f12866)"
+           id="g590">
+          <path
+             fill="#09102b"
+             d="m 358.17187,562.08984 c -1.19531,0.76172 -2.16015,1.45703 -3.19921,2.02344 -3.46094,1.87891 -6.86329,3.89453 -10.45313,5.5 -3.87109,1.73047 -8.14062,-0.26953 -10.125,-4.14453 -0.5,-0.96484 -1.69141,-1.5625 -2.67578,-2.41797 -0.13672,-1.35937 1.17969,-1.5625 2.09375,-2.03906 8.29297,-4.31641 15.45703,-10.17188 22.07812,-16.66406 2.53516,-2.48047 4.60938,-5.44922 6.80079,-8.26563 1.71875,-2.21484 1.94921,-2.53516 4.60546,-1.53125 4.74219,1.79297 8.49219,4.66797 10.34375,9.73828 3.22657,8.80469 6.95704,17.42969 8.59375,26.74219 0.26172,1.51172 0.33594,3.0625 0.59375,5.5 -3.77343,-1.86719 -7.05859,-2.78516 -8.24609,-6.56641 -0.72656,-2.32031 -1.48828,-4.61718 -2.5,-7.78906 -1.25781,2.66406 -2.09766,4.50781 -2.99219,6.32031 -6.76172,13.64844 -16.28906,24.96875 -29.98828,31.73828 -12.46484,6.16797 -25.84765,9.05469 -39.78906,5.21875 -11.70703,-3.23437 -20.39844,-10.70703 -27.02734,-20.60156 -2.64844,-3.96875 -4.57422,-8.4375 -6.70313,-12.73828 -0.55469,-1.11328 -0.65234,-2.44141 -0.95312,-3.68359 0.30078,-0.15625 0.60156,-0.31641 0.90625,-0.47657 1.17578,1.30469 2.42578,2.55469 3.48828,3.94532 0.66406,0.87109 1.05859,1.94922 1.53515,2.95312 6.10547,12.90625 16.76953,18.96094 30.5625,19.90625 10.53516,0.72656 20.27344,-2.26562 29.27735,-7.62109 9.51172,-5.64063 17.07812,-13.32813 22.98047,-22.6836 0.26953,-0.41406 0.51171,-0.84765 0.71875,-1.28906 0.0781,-0.20312 0.0351,-0.46484 0.0742,-1.07422 z m 0,0"
+             fill-opacity="1"
+             fill-rule="nonzero"
+             id="path588" />
+        </g>
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#a3af3eb6b6)"
+     id="g600"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#09102b"
+       d="m 704.36719,330.69531 c 1.40625,-2.07812 3.07422,-1.63672 4.66797,-1.07812 4.41406,1.53125 8.38281,3.79297 11.63281,7.23828 10.34375,10.98828 17.05859,23.99609 20.78125,38.50781 3.82031,14.875 2.98047,29.55469 -3.1211,43.75 -2.87109,6.67969 -6.11328,13.20703 -9.29687,20.03516 0.74219,-0.2461 1.6875,-0.47266 2.58203,-0.85938 6.08203,-2.59765 7.51172,-2.37109 12.3125,2.26953 1.07422,1.03516 1.95703,2.26563 3.19531,3.70703 -1.25,0.77735 -2.1289,1.35547 -3.04687,1.88672 -9.82422,5.69532 -19.75781,11.22266 -29.42188,17.19922 -2.34375,1.44531 -4.15234,1.31641 -6.14453,0.36719 -4.0039,-1.91797 -6.86328,-5.28906 -9.32812,-8.80078 -0.86328,-1.22656 -0.58203,-3.52344 -0.33594,-5.25781 1.86328,-12.69922 2.53906,-25.44922 1.51953,-38.23438 -0.32422,-3.98828 -1.25,-7.91797 -1.94922,-12.22656 1.26953,-0.47266 2.67969,0.3125 3.875,1.0664 5.60547,3.54297 10.27735,7.85157 11.26563,14.91797 0.46484,3.33985 0.95703,6.66797 1.39062,10.00782 0.19141,1.48437 0.23438,2.99218 0.375,4.83593 7.40625,-6.82031 14.4961,-36.78515 12.53906,-51.98437 -2.3789,-18.48047 -10.55859,-34.16406 -23.49218,-47.34766 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path598" />
+  </g>
+  <g
+     clip-path="url(#31f8f05393)"
+     id="g610"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       clip-path="url(#41889181af)"
+       id="g608">
+      <g
+         clip-path="url(#fe9d13e8b4)"
+         id="g606">
+        <g
+           clip-path="url(#6c6e35ef02)"
+           id="g604">
+          <path
+             fill="#09102b"
+             d="m 509.19922,356.76172 c -0.71094,1.38672 0.0273,2.15234 0.80469,2.83984 2.14062,1.92188 4.55078,3.38281 7.39453,4.10156 9.04687,2.27735 18.11718,1.99219 27.11328,-0.35156 9.22656,-2.40234 16.95703,-7.25781 22.86719,-14.80469 2.77734,-3.55078 5.36328,-7.2539 8.1289,-11.01953 0.0859,0.47657 0.2461,1.05469 0.30078,1.65235 0.39453,4.05468 0.94141,4.75781 4.89453,5.94922 0.88282,0.27343 1.8125,0.3789 2.96485,0.61328 0.0508,-0.90625 0.10547,-1.55469 0.11719,-2.20703 0.17968,-7.00391 0.23437,-14.01172 0.61328,-21.01172 0.0859,-1.69922 -0.52344,-2.63282 -1.62891,-3.42188 -2.23047,-1.58203 -4.91797,-2.11328 -7.55859,-2.39062 -0.92188,-0.0937 -2.08594,0.74609 -2.95703,1.39843 -6.35157,4.8125 -13.08594,9 -20.34375,12.28516 -2.26172,1.01953 -4.67579,1.70313 -7.22657,2.61719 0.1211,0.82422 0.96875,1.35156 1.73047,1.76562 3.59375,1.96094 7.32422,3.1836 11.46094,1.59766 1.95703,-0.75 3.91406,-1.48047 5.85547,-2.25 0.86719,-0.34375 1.69922,-0.77344 2.74219,-1.25 -1.50782,6.03516 -15.69532,18.84375 -24.54297,22.34766 -10.75782,4.26171 -21.71485,4.55859 -32.73047,1.53906 z m 0,0"
+             fill-opacity="1"
+             fill-rule="nonzero"
+             id="path602" />
+        </g>
+      </g>
+    </g>
+  </g>
+  <g
+     clip-path="url(#9d2f7452d2)"
+     id="g614"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#09102b"
+       d="m 547.03516,293.51172 h 54.54296 c 1.38282,0 2.51563,-1.12891 2.51563,-2.50781 v -40.83594 h -59.57422 v 40.83594 c 0,1.3789 1.13281,2.50781 2.51563,2.50781 z m 16.36328,-33.44531 h 21.8125 c 1.5,0 2.72656,1.22265 2.72656,2.71484 0,1.49219 -1.22656,2.71484 -2.72656,2.71484 h -21.8125 c -1.4961,0 -2.72266,-1.22265 -2.72266,-2.71484 0,-1.49219 1.22656,-2.71484 2.72266,-2.71484 z m 0,0"
+       fill-opacity="1"
+       fill-rule="evenodd"
+       id="path612" />
+  </g>
+  <g
+     clip-path="url(#5d999a0038)"
+     id="g618"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#09102b"
+       d="m 554.07812,219.76172 h 1.70313 c 1.91797,0 3.48047,1.55859 3.48047,3.47265 0,1.91016 -1.5625,3.46875 -3.48047,3.46875 h -8.76953 c -1.91797,0 -3.48047,-1.55859 -3.48047,-3.46875 0,-1.83984 1.44922,-3.35546 3.26562,-3.46484 v 1.73828 c -0.85546,0.10938 -1.52734,0.84375 -1.52734,1.72656 0,0.87891 0.67188,1.61719 1.52734,1.72266 v 0.004 h 0.0469 c 0.0547,0.008 0.10937,0.008 0.16797,0.008 h 8.76953 c 0.95703,0 1.74219,-0.78125 1.74219,-1.73438 0,-0.95703 -0.78516,-1.73828 -1.74219,-1.73828 h -1.70313 z m 0,0"
+       fill-opacity="1"
+       fill-rule="nonzero"
+       id="path616" />
+  </g>
+  <g
+     clip-path="url(#a4f0b4e13e)"
+     id="g622"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#09102b"
+       d="M 594.1875,248.43359 H 548.53516 V 228.4375 h 7.24609 c 2.875,0 5.21875,-2.33594 5.21875,-5.20313 0,-2.86718 -2.34375,-5.20703 -5.21875,-5.20703 h -3.44141 v 5.20313 h -3.80468 v -6.04297 c 0,-0.92188 0.73437,-1.67578 1.6289,-1.67578 h 42.39453 c 0.89844,0 1.62891,0.7539 1.62891,1.67578 z m -39.69922,-5.64062 h 33.75 v 1.73047 h -33.75 z m 0,-4.61719 h 33.75 v 1.73438 h -33.75 z m 8.23047,-14.98047 h 17.28906 v 1.73438 h -17.28906 z m 4.13281,-3.77734 h 9.01953 v 1.73437 h -9.01953 z m -12.36328,14.14453 h 33.75 v 1.73437 h -33.75 z m 0,0"
+       fill-opacity="1"
+       fill-rule="evenodd"
+       id="path620" />
+  </g>
+  <g
+     clip-path="url(#0ea259bc34)"
+     id="g626"
+     transform="translate(-43.488732,-201.52699)">
+    <path
+       fill="#09102b"
+       d="m 595.92969,248.43359 h 4.14843 V 217.1875 c 0,-0.92188 -0.73437,-1.67578 -1.63281,-1.67578 h -2.95312 c 0.27734,0.49609 0.4375,1.07031 0.4375,1.67578 z m 0,0"
+       fill-opacity="1"
+       fill-rule="evenodd"
+       id="path624" />
+  </g>
+  <g
+     fill="#ffffff"
+     fill-opacity="1"
+     id="g634"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(549.69852,280.96421)"
+       id="g632">
+      <g
+         id="g630">
+        <path
+           d="m 4.421875,0.109375 c -0.75,0 -1.414063,-0.1484375 -1.984375,-0.453125 -0.5625,-0.3125 -1.007812,-0.773438 -1.328125,-1.390625 -0.3125,-0.625 -0.46875,-1.394531 -0.46875,-2.3125 0,-0.90625 0.15625,-1.671875 0.46875,-2.296875 0.320313,-0.625 0.765625,-1.085938 1.328125,-1.390625 0.570312,-0.3125 1.234375,-0.46875 1.984375,-0.46875 0.78125,0 1.441406,0.152344 1.984375,0.453125 0.539062,0.304688 0.925781,0.765625 1.15625,1.390625 l -1.15625,0.71875 H 6.265625 c -0.179687,-0.425781 -0.417969,-0.726563 -0.71875,-0.90625 -0.292969,-0.1875 -0.667969,-0.28125 -1.125,-0.28125 -0.679687,0 -1.203125,0.226563 -1.578125,0.671875 -0.375,0.4375 -0.5625,1.140625 -0.5625,2.109375 0,0.96875 0.1875,1.679687 0.5625,2.125 0.375,0.4375 0.898438,0.65625 1.578125,0.65625 1.050781,0 1.691406,-0.507813 1.921875,-1.53125 h 0.140625 l 1.1875,0.609375 C 7.441406,-1.414062 7.0625,-0.835938 6.53125,-0.453125 6,-0.078125 5.296875,0.109375 4.421875,0.109375 Z m 0,0"
+           id="path628" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#ffffff"
+     fill-opacity="1"
+     id="g642"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(557.62495,280.96421)"
+       id="g640">
+      <g
+         id="g638">
+        <path
+           d="m 4.171875,-8.09375 c 0.582031,0 1.078125,0.109375 1.484375,0.328125 0.414062,0.210937 0.726562,0.507813 0.9375,0.890625 0.207031,0.375 0.3125,0.820312 0.3125,1.328125 0,0.5 -0.105469,0.945313 -0.3125,1.328125 -0.210938,0.375 -0.523438,0.671875 -0.9375,0.890625 -0.40625,0.210937 -0.902344,0.3125 -1.484375,0.3125 H 2.65625 V 0 H 1.046875 v -8.09375 z m -0.203125,3.8125 c 0.882812,0 1.328125,-0.421875 1.328125,-1.265625 0,-0.84375 -0.445313,-1.265625 -1.328125,-1.265625 h -1.3125 v 2.53125 z m 0,0"
+           id="path636" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#ffffff"
+     fill-opacity="1"
+     id="g650"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(565.00968,280.96421)"
+       id="g648">
+      <g
+         id="g646">
+        <path
+           d="M 1.34375,2.59375 C 1.082031,2.59375 0.847656,2.570312 0.640625,2.53125 0.429688,2.488281 0.257812,2.4375 0.125,2.375 L 0.359375,1.125 0.46875,1.09375 C 0.5625,1.144531 0.675781,1.179688 0.8125,1.203125 0.945312,1.234375 1.085938,1.25 1.234375,1.25 1.472656,1.25 1.675781,1.21875 1.84375,1.15625 2.007812,1.09375 2.148438,0.984375 2.265625,0.828125 2.378906,0.679688 2.476562,0.476562 2.5625,0.21875 L 0.125,-6.09375 H 1.734375 L 3.25,-1.859375 h 0.140625 l 1.46875,-4.234375 h 1.5625 L 3.96875,0.375 C 3.769531,0.90625 3.550781,1.328125 3.3125,1.640625 3.082031,1.960938 2.804688,2.203125 2.484375,2.359375 2.171875,2.515625 1.789062,2.59375 1.34375,2.59375 Z m 0,0"
+           id="path644" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#ffffff"
+     fill-opacity="1"
+     id="g658"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(571.55424,280.96421)"
+       id="g656">
+      <g
+         id="g654">
+        <path
+           d="m 4.203125,-1.453125 0.40625,1.125 C 4.441406,-0.179688 4.234375,-0.0703125 3.984375,0 3.734375,0.0703125 3.445312,0.109375 3.125,0.109375 c -0.65625,0 -1.15625,-0.1757812 -1.5,-0.53125 -0.34375,-0.363281 -0.515625,-0.882813 -0.515625,-1.5625 v -2.90625 H 0.1875 v -1.21875 h 0.921875 v -1.1875 l 1.53125,-0.25 v 1.4375 H 4.375 v 1.21875 H 2.640625 v 2.78125 c 0,0.3125 0.0625,0.539063 0.1875,0.671875 0.125,0.136719 0.304687,0.203125 0.546875,0.203125 0.269531,0 0.507812,-0.070313 0.71875,-0.21875 z m 0,0"
+           id="path652" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#ffffff"
+     fill-opacity="1"
+     id="g666"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(576.2913,280.96421)"
+       id="g664">
+      <g
+         id="g662">
+        <path
+           d="m 0.875,0 v -8.546875 h 1.53125 v 3.25 l 0.125,0.015625 c 0.195312,-0.300781 0.441406,-0.53125 0.734375,-0.6875 0.300781,-0.164062 0.660156,-0.25 1.078125,-0.25 1.34375,0 2.015625,0.765625 2.015625,2.296875 V 0 h -1.53125 v -3.734375 c 0,-0.414063 -0.085937,-0.71875 -0.25,-0.90625 -0.167969,-0.1875 -0.421875,-0.28125 -0.765625,-0.28125 -0.4375,0 -0.78125,0.148437 -1.03125,0.4375 -0.25,0.28125 -0.375,0.726563 -0.375,1.328125 V 0 Z m 0,0"
+           id="path660" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#ffffff"
+     fill-opacity="1"
+     id="g674"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(583.43283,280.96421)"
+       id="g672">
+      <g
+         id="g670">
+        <path
+           d="M 3.546875,0.109375 C 2.953125,0.109375 2.425781,-0.0078125 1.96875,-0.25 1.519531,-0.5 1.171875,-0.859375 0.921875,-1.328125 c -0.25,-0.476563 -0.375,-1.050781 -0.375,-1.71875 0,-0.664063 0.125,-1.238281 0.375,-1.71875 0.25,-0.476563 0.597656,-0.835937 1.046875,-1.078125 0.457031,-0.25 0.984375,-0.375 1.578125,-0.375 0.59375,0 1.113281,0.125 1.5625,0.375 0.457031,0.242188 0.8125,0.601562 1.0625,1.078125 0.25,0.480469 0.375,1.054687 0.375,1.71875 0,0.667969 -0.125,1.242187 -0.375,1.71875 -0.25,0.46875 -0.605469,0.828125 -1.0625,1.078125 -0.449219,0.2421875 -0.96875,0.359375 -1.5625,0.359375 z m 0,-1.296875 c 0.945313,0 1.421875,-0.617188 1.421875,-1.859375 0,-0.644531 -0.125,-1.117187 -0.375,-1.421875 -0.242188,-0.300781 -0.589844,-0.453125 -1.046875,-0.453125 -0.949219,0 -1.421875,0.625 -1.421875,1.875 0,1.242187 0.472656,1.859375 1.421875,1.859375 z m 0,0"
+           id="path668" />
+      </g>
+    </g>
+  </g>
+  <g
+     fill="#ffffff"
+     fill-opacity="1"
+     id="g682"
+     transform="translate(-43.488732,-201.52699)">
+    <g
+       transform="translate(590.51908,280.96421)"
+       id="g680">
+      <g
+         id="g678">
+        <path
+           d="m 0.875,0 v -6.09375 h 1.46875 v 0.890625 l 0.125,0.03125 c 0.375,-0.695313 0.988281,-1.046875 1.84375,-1.046875 0.707031,0 1.222656,0.195312 1.546875,0.578125 0.332031,0.386719 0.5,0.945313 0.5,1.671875 V 0 h -1.53125 v -3.78125 c 0,-0.40625 -0.085937,-0.695312 -0.25,-0.875 C 4.421875,-4.832031 4.164062,-4.921875 3.8125,-4.921875 3.363281,-4.921875 3.015625,-4.78125 2.765625,-4.5 2.523438,-4.21875 2.40625,-3.769531 2.40625,-3.15625 V 0 Z m 0,0"
+           id="path676" />
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/sources/shiboken6/doc/images/shibokenqtarch.png b/sources/shiboken6/doc/images/shibokenqtarch.png
index 359413373..c20ba4624 100644
--- a/sources/shiboken6/doc/images/shibokenqtarch.png
+++ b/sources/shiboken6/doc/images/shibokenqtarch.png
diff --git a/sources/shiboken6/doc/images/shibokenqtarch.svg b/sources/shiboken6/doc/images/shibokenqtarch.svg
index d9212f18c..8f52b8db4 100644
--- a/sources/shiboken6/doc/images/shibokenqtarch.svg
+++ b/sources/shiboken6/doc/images/shibokenqtarch.svg
@@ -2,24 +2,24 @@
 <!-- Created with Inkscape (http://www.inkscape.org/) -->
 
 <svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
    width="275"
    height="197.55103"
    id="svg2"
    sodipodi:version="0.32"
-   inkscape:version="0.92.2 2405546, 2018-03-11"
+   inkscape:version="1.2.2 (b0a8486541, 2022-12-01)"
    version="1.0"
    sodipodi:docname="shibokenqtarch.svg"
    inkscape:output_extension="org.inkscape.output.svg.inkscape"
    inkscape:export-filename="shibokenqtarch.png"
    inkscape:export-xdpi="90"
-   inkscape:export-ydpi="90">
+   inkscape:export-ydpi="90"
+   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"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:dc="http://purl.org/dc/elements/1.1/">
   <defs
      id="defs4">
     <marker
@@ -54,23 +54,26 @@
      objecttolerance="10"
      inkscape:pageopacity="0.0"
      inkscape:pageshadow="2"
-     inkscape:zoom="1.0474359"
-     inkscape:cx="110.19617"
-     inkscape:cy="69.09871"
+     inkscape:zoom="2.0948718"
+     inkscape:cx="130.07956"
+     inkscape:cy="99.051407"
      inkscape:document-units="px"
      inkscape:current-layer="layer1"
      showgrid="true"
-     inkscape:window-width="1002"
-     inkscape:window-height="1042"
-     inkscape:window-x="10"
-     inkscape:window-y="28"
+     inkscape:window-width="2552"
+     inkscape:window-height="1432"
+     inkscape:window-x="1924"
+     inkscape:window-y="4"
      showguides="true"
      inkscape:guide-bbox="true"
      fit-margin-top="0"
      fit-margin-left="0"
      fit-margin-right="0"
      fit-margin-bottom="0"
-     inkscape:window-maximized="0">
+     inkscape:window-maximized="0"
+     inkscape:showpageshadow="2"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1">
     <inkscape:grid
        type="xygrid"
        id="grid44"
@@ -85,7 +88,7 @@
         <dc:format>image/svg+xml</dc:format>
         <dc:type
            rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
+        <dc:title />
       </cc:Work>
     </rdf:RDF>
   </metadata>
@@ -114,7 +117,7 @@
        sodipodi:nodetypes="ccccccc" />
     <text
        xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:16.68707466px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:1.12244904;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+       style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:16.6871px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:1.12245;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
        x="120.87232"
        y="334.88406"
        id="text153"><tspan
@@ -122,10 +125,10 @@
          id="tspan151"
          x="120.87232"
          y="334.88406"
-         style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:16.68707466px;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:1.12244904;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1">Qt for Python</tspan></text>
+         style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:16.6871px;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:1.12245;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1">Qt for Python</tspan></text>
     <text
        xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.74510956px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:Titillium;letter-spacing:0px;word-spacing:0px;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.31862774"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.7451px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:Titillium;letter-spacing:0px;word-spacing:0px;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.318628"
        x="121.09701"
        y="354.01886"
        id="text157"><tspan
@@ -133,7 +136,7 @@
          x="121.09701"
          y="354.01886"
          id="tspan159"
-         style="fill:#ffffff;fill-opacity:1;stroke-width:0.31862774">Qt classes and functions exported to Python</tspan></text>
+         style="fill:#ffffff;fill-opacity:1;stroke-width:0.318628">Qt classes and functions exported to Python</tspan></text>
     <path
        style="fill:#53586b;fill-opacity:1;stroke:none;stroke-width:2.20567369;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
        d="m 106.0768,391.19877 v 44.89796 h 262.2093 l 12.7907,-11.22449 V 379.97428 H 117.53514 Z"
@@ -142,7 +145,7 @@
        sodipodi:nodetypes="ccccccc" />
     <text
        xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:16.68707466px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.41717955"
+       style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:16.6871px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.41718"
        x="121.0225"
        y="403.38095"
        id="text153-2"><tspan
@@ -150,10 +153,10 @@
          id="tspan151-9"
          x="121.0225"
          y="403.38095"
-         style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:16.68707466px;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.41717955">Shiboken</tspan></text>
+         style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:16.6871px;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.41718">Shiboken</tspan></text>
     <text
        xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.74510956px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:Titillium;letter-spacing:0px;word-spacing:0px;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.31862774"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.7451px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:Titillium;letter-spacing:0px;word-spacing:0px;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.318628"
        x="121.09701"
        y="421.95245"
        id="text157-1"><tspan
@@ -161,10 +164,10 @@
          x="121.09701"
          y="421.95245"
          id="tspan159-2"
-         style="fill:#ffffff;fill-opacity:1;stroke-width:0.31862774">Generator that exposes C++ classes to Python</tspan></text>
+         style="fill:#ffffff;fill-opacity:1;stroke-width:0.318628">Generator that exposes C++ classes to Python</tspan></text>
     <text
        xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:17.95918465px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.31862774"
+       style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:17.9592px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.318628"
        x="123.35368"
        y="482.61551"
        id="text157-1-7"><tspan
@@ -172,17 +175,17 @@
          x="123.35368"
          y="482.61551"
          id="tspan159-2-0"
-         style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:17.95918465px;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.31862774">CPython API</tspan></text>
+         style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:17.9592px;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.318628">CPython API</tspan></text>
     <text
        xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:17.95918465px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.4132798"
-       x="265.1445"
-       y="483.19019"
+       style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:17.9592px;line-height:1.25;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.41328"
+       x="271.38934"
+       y="483.42886"
        id="text157-1-9"><tspan
          sodipodi:role="line"
-         x="265.1445"
-         y="483.19019"
+         x="271.38934"
+         y="483.42886"
          id="tspan159-2-3"
-         style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:17.95918465px;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.4132798">Qt 5 Libraries</tspan></text>
+         style="font-style:normal;font-variant:normal;font-weight:600;font-stretch:normal;font-size:17.9592px;font-family:Titillium;-inkscape-font-specification:'Titillium, Semi-Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke-width:0.41328">Qt  Libraries</tspan></text>
   </g>
 </svg>
diff --git a/sources/shiboken6/doc/index.rst b/sources/shiboken6/doc/index.rst
index d7cb4c2b1..68f96dded 100644
--- a/sources/shiboken6/doc/index.rst
+++ b/sources/shiboken6/doc/index.rst
@@ -25,73 +25,92 @@ Shiboken
 Documentation
 =============
 
-.. panels::
-    :body: text-center
-    :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
 
-    Install and build from source.
+    .. grid-item-card::
+        :class-item: text-center
 
-    +++
+        Install and build from source.
+        +++
+        .. button-ref:: gettingstarted
+            :color: primary
+            :outline:
+            :expand:
 
-    .. link-button:: gettingstarted
-        :type: ref
-        :text: Getting Started
-        :classes: btn-qt btn-block stretched-link
-    ---
+            Getting Started
 
-    Binding generator executable.
+    .. grid-item-card::
+        :class-item: text-center
 
-    +++
+        Binding generator executable.
+        +++
+        .. button-ref:: shibokengenerator
+            :color: primary
+            :outline:
+            :expand:
 
-    .. link-button:: shibokengenerator
-        :type: ref
-        :text: Shiboken Generator
-        :classes: btn-qt btn-block stretched-link
-    ---
+            Shiboken Generator
 
-    Python utility module.
+    .. grid-item-card::
+        :class-item: text-center
 
-    +++
+        Python utility module.
+        +++
+        .. button-ref:: shibokenmodule
+            :color: primary
+            :outline:
+            :expand:
 
-    .. link-button:: shibokenmodule
-        :type: ref
-        :text: Shiboken Module
-        :classes: btn-qt btn-block stretched-link
+            Shiboken Module
 
-    ---
+    .. grid-item-card::
+        :class-item: text-center
 
-    Reference and functionallities.
+        Reference and functionallities.
+        +++
+        .. button-ref:: typesystem
+            :color: primary
+            :outline:
+            :expand:
 
-    +++
+            Type System
 
-    .. link-button:: typesystem
-        :type: ref
-        :text: Type System
-        :classes: btn-qt btn-block stretched-link
+    .. grid-item-card::
+        :class-item: text-center
 
-    ---
+        Using Shiboken.
+        +++
+        .. button-ref:: examples/index
+            :color: primary
+            :outline:
+            :expand:
 
-    Using Shiboken.
+            Examples
 
-    +++
+    .. grid-item-card::
+        :class-item: text-center
 
-    .. link-button:: examples/index
-        :type: ref
-        :text: Examples
-        :classes: btn-qt btn-block stretched-link
+        Generating Python stub files.
+        +++
+        .. button-ref:: shiboken-genpyi
+            :color: primary
+            :outline:
+            :expand:
 
-    ---
+            shiboken6-genpyi
 
-    Known issues and FAQ.
+    .. grid-item-card::
+        :class-item: text-center
 
-    +++
-
-    .. link-button:: considerations
-        :type: ref
-        :text: Considerations
-        :classes: btn-qt btn-block stretched-link
+        Known issues and FAQ.
+        +++
+        .. button-ref:: considerations
+            :color: primary
+            :outline:
+            :expand:
 
+            Considerations
 
 .. toctree::
    :hidden:
@@ -102,4 +121,5 @@ Documentation
    shibokenmodule.rst
    typesystem.rst
    examples/index.rst
+   shiboken-genpyi.rst
    considerations.rst
diff --git a/sources/shiboken6/doc/shiboken-genpyi.rst b/sources/shiboken6/doc/shiboken-genpyi.rst
new file mode 100644
index 000000000..44d0edb97
--- /dev/null
+++ b/sources/shiboken6/doc/shiboken-genpyi.rst
@@ -0,0 +1,32 @@
+.. _shiboken6-genpyi:
+
+shiboken6-genpyi
+================
+
+`shiboken6-genpyi` is a command line tool to generate Python stub files
+(.pyi) for any shiboken binding-based module (not just PySide). Stub
+files define signatures of all classes, methods (including overloads),
+constants and enums of a module. Signatures also contain type hints.
+This helps your module integrate with Python type checkers and IDEs.
+For example, if you use any function from your module, your IDE's
+function lookup feature will show you the function signature and its
+parameters and return value including types.
+
+
+Usage
+-----
+
+To generate stub files for a module, run the following command:
+
+.. code-block:: bash
+
+    shiboken6-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.
diff --git a/sources/shiboken6/doc/shibokengenerator.rst b/sources/shiboken6/doc/shibokengenerator.rst
index 01b4420ee..14340ab69 100644
--- a/sources/shiboken6/doc/shibokengenerator.rst
+++ b/sources/shiboken6/doc/shibokengenerator.rst
@@ -52,13 +52,13 @@ Handwritten inputs
 Creating new bindings involves creating several pieces of "code": the header,
 the typesystem and, in most cases, the injected code.
 
-:header: A header with ``#include`` directives listing all the headers of the
-         desired classes. This header is not referenced by the generated code.
-         Alternatively, it is possible to pass a list of the headers of the
-         desired classes directly on the command line. In this case,
-         the command line option ``--use-global-header`` should be passed as
-         well to prevent the headers from being suppressed in the generated
-         code.
+**header** A header with ``#include`` directives listing all the headers of the
+    desired classes. This header is not referenced by the generated code.
+    Alternatively, it is possible to pass a list of the headers of the
+    desired classes directly on the command line. In this case,
+    the command line option ``--use-global-header`` should be passed as
+    well to prevent the headers from being suppressed in the generated
+    code.
 
 ::ref:`typesystem`: XML files that provides the developer with a tool to customize the
              way that the generators will see the classes and functions. For
@@ -112,21 +112,25 @@ Options
 ``--avoid-protected-hack``
     Avoid the use of the '#define protected public' hack.
 
-.. _use-isnull-as-nb-nonzero:
+.. _use-isnull-as-nb-bool:
 
-``--use-isnull-as-nb_nonzero``
+``--use-isnull-as-nb-bool``
     If a class has an isNull() const method, it will be used to
     compute the value of boolean casts (see :ref:`bool-cast`).
+    The legacy option ``--use-isnull-as-nb_nonzero`` has the
+    same effect, but should not be used any more.
 
 ``--lean-headers``
     Forward declare classes in module headers instead of including their class
     headers where possible.
 
-.. _use-operator-bool-as-nb-nonzero:
+.. _use-operator-bool-as-nb-bool:
 
-``--use-operator-bool-as-nb_nonzero``
+``--use-operator-bool-as-nb-bool``
     If a class has an operator bool, it will be used to compute
     the value of boolean casts (see :ref:`bool-cast`).
+    The legacy option ``--use-operator-bool-as-nb_nonzero`` has the
+    same effect, but should not be used any more.
 
 .. _no-implicit-conversions:
 
@@ -212,7 +216,7 @@ Options
 ``-I<path>, --include-paths=<path>[:<path>:...]``
     Include paths used by the C++ parser.
 
-... _system-include-paths:
+.. _system-include-paths:
 
 ``-isystem<path>, --system-include-paths=<path>[:<path>:...]``
     System include paths used by the C++ parser
@@ -222,6 +226,12 @@ Options
 ``-F<path>, --framework-include-paths=<path>[:<path>:...]``
     Framework include paths used by the C++ parser
 
+.. _force-process-system-include-paths:
+
+``--force-process-system-include-paths=<path>[:<path>:...]``
+    Include paths that are considered as system headers by the C++ parser,
+    but should still be processed to extract types
+
 .. _language-level:
 
 ``--language-level=, -std=<level>``
@@ -247,6 +257,10 @@ Options
 ``--no-suppress-warnings``
     Show all warnings.
 
+``--log-unmatched``
+    Prints :ref:`suppress-warning` and :ref:`rejection` elements that were
+    not matched. This is useful for cleaning up old type system files.
+
 .. _silent:
 
 ``--silent``
@@ -308,6 +322,9 @@ QtDocGenerator Options
 ``--inheritance-file=<file>``
    Generate a JSON file containing the class inheritance.
 
+``--disable-inheritance-diagram``
+        Disable the generation of the inheritance diagram.
+
 .. _project-file:
 
 ********************
@@ -325,18 +342,18 @@ The project file structure
 
 Here follows a comprehensive example of a generator project file.
 
-    .. code-block:: ini
+.. code-block:: ini
 
-         [generator-project]
-         generator-set = path/to/generator/CHOICE_GENERATOR
-         header-file = DIR/global.h" />
-         typesystem-file = DIR/typesystem_for_your_binding.xml
-         output-directory location="OUTPUTDIR" />
-         include-path = path/to/library/being/wrapped/headers/1
-         include-path = path/to/library/being/wrapped/headers/2
-         typesystem-path = path/to/directory/containing/type/system/files/1
-         typesystem-path = path/to/directory/containing/type/system/files/2
-         enable-parent-ctor-heuristic
+     [generator-project]
+     generator-set = path/to/generator/CHOICE_GENERATOR
+     header-file = DIR/global.h" />
+     typesystem-file = DIR/typesystem_for_your_binding.xml
+     output-directory location="OUTPUTDIR" />
+     include-path = path/to/library/being/wrapped/headers/1
+     include-path = path/to/library/being/wrapped/headers/2
+     typesystem-path = path/to/directory/containing/type/system/files/1
+     typesystem-path = path/to/directory/containing/type/system/files/2
+     enable-parent-ctor-heuristic
 
 
 Project file tags
@@ -352,26 +369,25 @@ generator project file following simple conversion rules.
 For tags without options, just write as an empty tag without any attributes.
 Example:
 
-    .. code-block:: bash
+.. code-block:: bash
 
-         --BOOLEAN-ARGUMENT
+     --BOOLEAN-ARGUMENT
 
 becomes
 
-    .. code-block:: ini
+.. code-block:: ini
 
-         BOOLEAN-ARGUMENT
+     BOOLEAN-ARGUMENT
 
 and
 
-    .. code-block:: bash
+.. code-block:: bash
 
-         --VALUE-ARGUMENT=VALUE
+     --VALUE-ARGUMENT=VALUE
 
 becomes
 
-    .. code-block:: ini
-
-         VALUE-ARGUMENT = VALUE
+.. code-block:: ini
 
+     VALUE-ARGUMENT = VALUE
 
diff --git a/sources/shiboken6/doc/shibokenmodule.rst b/sources/shiboken6/doc/shibokenmodule.rst
index 91cb3fa6e..3bc4fa6ba 100644
--- a/sources/shiboken6/doc/shibokenmodule.rst
+++ b/sources/shiboken6/doc/shibokenmodule.rst
@@ -1,4 +1,4 @@
-. module:: shiboken
+.. module:: Shiboken
 
 .. |maya| unicode:: Maya U+2122
 
@@ -32,6 +32,11 @@ or just for debug purposes.
 Some function description refer to "Shiboken based objects", wich means
 Python objects instances of any Python Type created using Shiboken.
 
+To import the module:
+
+.. code-block:: python
+
+    from shiboken6 import Shiboken
 
 .. function:: isValid(obj)
 
@@ -110,3 +115,33 @@ Python objects instances of any Python Type created using Shiboken.
     internally the `str` function is called with it.
 
     This method should be used **only** for debug purposes by developers.
+
+ .. function:: dumpTypeGraph(file_name)
+
+    Dumps the inheritance graph of the types existing in libshiboken
+    to ``.dot`` file for use with `Graphviz <https://graphviz.org/>`_.
+
+.. function:: dumpWrapperMap()
+
+    Dumps the map of wrappers existing in libshiboken to standard error.
+
+.. function:: dumpConverters()
+
+    Dumps the map of named converters existing in libshiboken to standard
+    error.
+
+ .. py:class:: VoidPtr(address, size = -1, writeable = 0)
+
+     :param address: (PyBuffer, SbkObject, int, VoidPtr)
+     :param size: int
+     :param writeable: int
+
+     Represents a chunk of memory by address and size and implements the ``buffer`` protocol.
+     It can be constructed from a ``buffer``, a Shiboken based object, a memory address
+     or another VoidPtr instance.
+
+     .. py:method:: toBytes()
+
+         :rtype: bytes
+
+         Returns the contents as ``bytes``.
diff --git a/sources/shiboken6/doc/typediscovery.rst b/sources/shiboken6/doc/typediscovery.rst
new file mode 100644
index 000000000..76d3adf7b
--- /dev/null
+++ b/sources/shiboken6/doc/typediscovery.rst
@@ -0,0 +1,145 @@
+.. _typediscovery:
+
+**************
+Type Discovery
+**************
+
+When converting objects which are part of a class hierarchy from a pointer to a
+base class, it is expected to get the Python type of the actual, most derived
+type, as opposed to C++ which requires a cast for this:
+
+.. code-block:: python
+
+    def event(self, event):
+        if event.type() == QEvent.Type.MousePress:
+            self.do_things(event.position())
+    ...
+
+
+.. code-block:: c++
+
+    bool event(QEvent *event) override
+    {
+        if (event->type() == QEvent::MousePress) {
+            auto *mouseEvent = static_cast<QMouseEvent *>(event);
+            doThings(mouseEvent->position());
+        ...
+    }
+
+The process of determining the type of the event is called `type discovery`.
+
+Shiboken generates code to automatically detect the type. First, it tries to
+find a converter for the name obtained by ``typeid(*pointer).name()``. This
+should normally work as this name is registered by the binding. If that fails,
+it starts walking a type inheritance graph built up in libshiboken to find the
+most derived class by using a cast function (``dynamic_cast<>`` by default) to
+check.
+
+For normal class hierarchies with virtual destructors, no special handling
+is required since ``typeid()`` usually detects the proper class name.
+
+Multiple inheritance
+====================
+
+In case of multiple inheritance in C++, the conversion to the derived class is
+not done in case it is not a single-line direct inheritance. For example, in
+Qt, the class ``QWidget`` inherits both ``QObject`` (base of the ``QObject``
+hierarchy) and ``QPaintDevice``.
+
+When calling a function returning a ``QPaintDevice *``, for example
+``QPainter.device()``, a Python type representing ``QPaintDevice`` is returned
+instead of the underlying widget type. This restriction exists because the
+underlying pointer in C++ is a pointer to a ``QPaintDevice *`` and differs from
+the pointer to the ``QWidget``.
+
+Hierarchies of classes with non-virtual destructors
+===================================================
+
+There are some hierarchies of value-ish C++ classes that do not have virtual
+destructors. This makes type discovery based on ``typeid()`` and
+``dynamic_cast<>`` impossible.
+
+Examples in Qt are the ``QStyleOption``-derived or the ``QGradient``
+-derived classes.
+
+For such classes, some attributes need to be specified on the type entries:
+
+Primarily, a :ref:`polymorphic-id-expression` attribute
+must be specified to be used as a check replacing ``dynamic_cast<>``.
+
+In addition, a :ref:`polymorphic-name-function` attribute can be specified.
+This replaces the type name guess obtained by ``typeid()`` and is mainly a hint
+to speed things up by skipping the checks for each type in the inheritance
+graph.
+
+A :ref:`polymorphic-base` attribute identifies the base class of a hierarchy.
+It should be given in case the base class inherits from another class to
+prevent the logic from going below the base class.
+
+Using type discovery attributes for class hierarchies with virtual destructors
+==============================================================================
+
+It is possible to use :ref:`polymorphic-id-expression` and
+:ref:`polymorphic-name-function` for normal class hierarchies with virtual
+destructors as well since they basically replace ``typeid()`` and
+``dynamic_cast<>``. This makes sense if expressions can be specified that are
+faster than the checks on virtual tables.
+
+Specifying :ref:`polymorphic-base` can also make sense for generating special
+cast functions in case of multiple inheritance. For example, in Qt,
+``QWindow``, ``QLayout``, ``QWidget`` are base classes of hierarchies. Since
+they all inherit from ``QObject``, indicating the base classes prevents
+the logic from using ``QObject`` as a base class.
+
+.. _typediscovery-attributes:
+
+Type discovery attributes reference
+===================================
+
+The following attributes related to type discovery may be be specified on the
+:ref:`object-type` or :ref:`value-type` elements:
+
+.. _polymorphic-id-expression:
+
+polymorphic-id-expression
++++++++++++++++++++++++++
+
+The **polymorphic-id-expression** attribute specifies an expression checking
+whether a base class pointer is of the matching type. For example, in a
+``virtual eventHandler(BaseEvent *e)`` function, this is used to construct a
+Python wrapper matching the derived class (for example, a ``MouseEvent`` or
+similar). The attribute value may contain placeholders:
+
+%1
+    Fully qualified class name
+
+%B
+    Fully qualified name of the base class (found by base class
+    search or as indicated by **polymorphic-base**).
+
+To check for a class inheriting ``BaseEvent``, specify:
+
+.. code-block:: xml
+
+        <object-type name="MouseEvent"
+                     polymorphic-id-expression="%B-&gt;type() == BaseEvent::MouseEvent"/>
+
+.. _polymorphic-name-function:
+
+polymorphic-name-function
++++++++++++++++++++++++++
+
+The **polymorphic-name-function** attribute specifies the name of a function
+returning the type name of a derived class on the base class type entry.
+Normally, ``typeid(ptr).name()`` is used for this.
+
+The function is expected to return ``const char *``.
+
+.. _polymorphic-base:
+
+polymorphic-base
+++++++++++++++++
+
+The boolean **polymorphic-base** attribute indicates whether the class is the
+base class of a class hierarchy. It is used for the *%B* placeholder in
+**polymorphic-id-expression** and for cast operations in multiple inheritance.
diff --git a/sources/shiboken6/doc/typesystem.rst b/sources/shiboken6/doc/typesystem.rst
index e1e4fdda2..26f929801 100644
--- a/sources/shiboken6/doc/typesystem.rst
+++ b/sources/shiboken6/doc/typesystem.rst
@@ -65,3 +65,4 @@ Extra options and Python caveats
 
    typesystem_solving_compilation.rst
    typesystem_specialfunctions.rst
+   typediscovery.rst
diff --git a/sources/shiboken6/doc/typesystem_arguments.rst b/sources/shiboken6/doc/typesystem_arguments.rst
index b6967e721..d950b6c32 100644
--- a/sources/shiboken6/doc/typesystem_arguments.rst
+++ b/sources/shiboken6/doc/typesystem_arguments.rst
@@ -8,77 +8,77 @@ Modifying Arguments
 conversion-rule
 ^^^^^^^^^^^^^^^
 
-    The ``conversion-rule`` node allows you to write customized code to convert
-    the given argument between the target language and C++.
-    It is then a child of the :ref:`modify-argument` node:
+The ``conversion-rule`` node allows you to write customized code to convert
+the given argument between the target language and C++.
+It is then a child of the :ref:`modify-argument` node:
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <modify-argument index="2">
-        <!-- for the second argument of the function -->
-        <conversion-rule class="target | native">
-            // the code
-        </conversion-rule>
-        </modify-argument>
+    <modify-argument index="2">
+    <!-- for the second argument of the function -->
+    <conversion-rule class="target | native">
+        // the code
+    </conversion-rule>
+    </modify-argument>
 
-    The ``class`` attribute accepts one of the following values to define the
-    conversion direction to be either ``target-to-native`` or ``native-to-target``:
+The ``class`` attribute accepts one of the following values to define the
+conversion direction to be either ``target-to-native`` or ``native-to-target``:
 
-        * ``native``: Defines the conversion direction to be ``target-to-native``.
-                      It is similar to the existing ``<target-to-native>`` element.
-                      See :ref:`Conversion Rule Tag <conversion-rule-tag>` for more information.
+* ``native``: Defines the conversion direction to be ``target-to-native``.
+              It is similar to the existing ``<target-to-native>`` element.
+              See :ref:`Conversion Rule Tag <conversion-rule-tag>` for more information.
 
-        * ``target``: Defines the conversion direction to be ``native-to-target``.
-                      It is similar to the existing ``<native-to-target>`` element.
-                      See :ref:`Conversion Rule Tag <conversion-rule-tag>` for more information.
+* ``target``: Defines the conversion direction to be ``native-to-target``.
+              It is similar to the existing ``<native-to-target>`` element.
+              See :ref:`Conversion Rule Tag <conversion-rule-tag>` for more information.
 
-    This node is typically used in combination with the :ref:`replace-type` and
-    :ref:`remove-argument` nodes. The given code is used instead of the generator's
-    conversion code.
+This node is typically used in combination with the :ref:`replace-type` and
+:ref:`remove-argument` nodes. The given code is used instead of the generator's
+conversion code.
 
-    Writing %N in the code (where N is a number), will insert the name of the
-    nth argument. Alternatively, %in and %out which will be replaced with the
-    name of the conversion's input and output variable, respectively. Note the
-    output variable must be declared explicitly, for example:
+Writing %N in the code (where N is a number), will insert the name of the
+nth argument. Alternatively, %in and %out which will be replaced with the
+name of the conversion's input and output variable, respectively. Note the
+output variable must be declared explicitly, for example:
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <conversion-rule class="native">
-        bool %out = (bool) %in;
-        </conversion-rule>
+    <conversion-rule class="native">
+    bool %out = (bool) %in;
+    </conversion-rule>
 
-    .. note::
+.. note::
 
-        You can also use the ``conversion-rule`` node to specify
-        :ref:`a conversion code which will be used instead of the generator's conversion code everywhere for a given type <conversion-rule-tag>`.
+    You can also use the ``conversion-rule`` node to specify
+    :ref:`a conversion code which will be used instead of the generator's conversion code everywhere for a given type <conversion-rule-tag>`.
 
 .. _remove-argument:
 
 remove-argument
 ^^^^^^^^^^^^^^^
 
-    The ``remove-argument`` node removes the given argument from the function's
-    signature, and it is a child of the :ref:`modify-argument` node.
+The ``remove-argument`` node removes the given argument from the function's
+signature, and it is a child of the :ref:`modify-argument` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-     <modify-argument>
-         <remove-argument />
-     </modify-argument>
+ <modify-argument>
+     <remove-argument />
+ </modify-argument>
 
 .. _rename-to:
 
 rename to
 ^^^^^^^^^
 
-    The ``rename to`` node is used to rename a argument and use this new name in
-    the generated code, and it is a child of the :ref:`modify-argument` node.
+The ``rename to`` node is used to rename a argument and use this new name in
+the generated code, and it is a child of the :ref:`modify-argument` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-     <modify-argument>
-         <rename to='...' />
-     </modify-argument>
+ <modify-argument>
+     <rename to='...' />
+ </modify-argument>
 
 .. warning:: This tag is deprecated, use the ``rename`` attribute from :ref:`modify-argument` tag instead.
 
@@ -87,143 +87,143 @@ rename to
 remove-default-expression
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-    The ``remove-default-expression`` node disables the use of the default expression
-    for the given argument, and it is a child of the :ref:`modify-argument` node.
+The ``remove-default-expression`` node disables the use of the default expression
+for the given argument, and it is a child of the :ref:`modify-argument` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <modify-argument...>
-             <remove-default-expression />
-         </modify-argument>
+     <modify-argument...>
+         <remove-default-expression />
+     </modify-argument>
 
 .. _replace-default-expression:
 
 replace-default-expression
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-    The ``replace-default-expression`` node replaces the specified argument with the
-    expression specified by the ``with`` attribute, and it is a child of the
-    :ref:`modify-argument` node.
+The ``replace-default-expression`` node replaces the specified argument with the
+expression specified by the ``with`` attribute, and it is a child of the
+:ref:`modify-argument` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <modify-argument>
-             <replace-default-expression with="..." />
-         </modify-argument>
+     <modify-argument>
+         <replace-default-expression with="..." />
+     </modify-argument>
 
 .. _replace-type:
 
 replace-type
 ^^^^^^^^^^^^
 
-    The ``replace-type`` node replaces the type of the given argument to the one
-    specified by the ``modified-type`` attribute, and it is a child of the
-    :ref:`modify-argument` node.
+The ``replace-type`` node replaces the type of the given argument to the one
+specified by the ``modified-type`` attribute, and it is a child of the
+:ref:`modify-argument` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <modify-argument>
-             <replace-type modified-type="..." />
-         </modify-argument>
+     <modify-argument>
+         <replace-type modified-type="..." />
+     </modify-argument>
 
-    If the new type is a class, the ``modified-type`` attribute must be set to
-    the fully qualified name (including name of the package as well as the class
-    name).
+If the new type is a class, the ``modified-type`` attribute must be set to
+the fully qualified name (including name of the package as well as the class
+name).
 
 .. _define-ownership:
 
 define-ownership
 ^^^^^^^^^^^^^^^^
 
-    The ``define-ownership`` tag indicates that the function changes the ownership
-    rules of the argument object, and it is a child of the
-    :ref:`modify-argument` node.
-    The ``class`` attribute specifies the class of
-    function where to inject the ownership altering code
-    (see :ref:`codegenerationterminology`). The ``owner`` attribute
-    specifies the new ownership of the object. It accepts the following values:
-
-        * target: the target language will assume full ownership of the object.
-                  The native resources will be deleted when the target language
-                  object is finalized.
-        * c++: The native code assumes full ownership of the object. The target
-               language object will not be garbage collected.
-        * default: The object will get default ownership, depending on how it
-                   was created.
-
-    .. code-block:: xml
-
-        <modify-argument>
-              <define-ownership class="target | native"
-                                owner="target | c++ | default" />
-        </modify-argument>
+The ``define-ownership`` tag indicates that the function changes the ownership
+rules of the argument object, and it is a child of the
+:ref:`modify-argument` node.
+The ``class`` attribute specifies the class of
+function where to inject the ownership altering code
+(see :ref:`codegenerationterminology`). The ``owner`` attribute
+specifies the new ownership of the object. It accepts the following values:
+
+* target: the target language will assume full ownership of the object.
+          The native resources will be deleted when the target language
+          object is finalized.
+* c++: The native code assumes full ownership of the object. The target
+       language object will not be garbage collected.
+* default: The object will get default ownership, depending on how it
+           was created.
+
+.. code-block:: xml
+
+    <modify-argument>
+          <define-ownership class="target | native"
+                            owner="target | c++ | default" />
+    </modify-argument>
 
 .. _reference-count:
 
 reference-count
 ^^^^^^^^^^^^^^^
 
-    The ``reference-count`` tag dictates how an argument should be handled by the
-    target language reference counting system (if there is any), it also indicates
-    the kind of relationship the class owning the function being modified has with
-    the argument. It is a child of the :ref:`modify-argument` node.
-    For instance, in a model/view relation a view receiving a model
-    as argument for a **setModel** method should increment the model's reference
-    counting, since the model should be kept alive as much as the view lives.
-    Remember that out hypothetical view could not become parent of the model,
-    since the said model could be used by other views as well.
-    The ``action`` attribute specifies what should be done to the argument
-    reference counting when the modified method is called. It accepts the
-    following values:
-
-        * add: increments the argument reference counter.
-        * add-all: increments the reference counter for each item in a collection.
-        * remove: decrements the argument reference counter.
-        * set: will assign the argument to the variable containing the reference.
-        * ignore: does nothing with the argument reference counter
-                  (sounds worthless, but could be used in situations
-                   where the reference counter increase is mandatory
-                   by default).
-
-    .. code-block:: xml
-
-        <modify-argument>
-              <reference-count action="add|add-all|remove|set|ignore" variable-name="..." />
-        </modify-argument>
-
-
-    The variable-name attribute specifies the name used for the variable that
-    holds the reference(s).
+The ``reference-count`` tag dictates how an argument should be handled by the
+target language reference counting system (if there is any), it also indicates
+the kind of relationship the class owning the function being modified has with
+the argument. It is a child of the :ref:`modify-argument` node.
+For instance, in a model/view relation a view receiving a model
+as argument for a **setModel** method should increment the model's reference
+counting, since the model should be kept alive as much as the view lives.
+Remember that out hypothetical view could not become parent of the model,
+since the said model could be used by other views as well.
+The ``action`` attribute specifies what should be done to the argument
+reference counting when the modified method is called. It accepts the
+following values:
+
+* add: increments the argument reference counter.
+* add-all: increments the reference counter for each item in a collection.
+* remove: decrements the argument reference counter.
+* set: will assign the argument to the variable containing the reference.
+* ignore: does nothing with the argument reference counter
+          (sounds worthless, but could be used in situations
+           where the reference counter increase is mandatory
+           by default).
+
+.. code-block:: xml
+
+    <modify-argument>
+          <reference-count action="add|add-all|remove|set|ignore" variable-name="..." />
+    </modify-argument>
+
+
+The variable-name attribute specifies the name used for the variable that
+holds the reference(s).
 
 .. _replace-value:
 
 replace-value
 ^^^^^^^^^^^^^
 
-    The ``replace-value`` attribute lets you replace the return statement of a
-    function with a fixed string. This attribute can only be used for the
-    argument at ``index`` 0, which is always the function's return value.
+The ``replace-value`` attribute lets you replace the return statement of a
+function with a fixed string. This attribute can only be used for the
+argument at ``index`` 0, which is always the function's return value.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <modify-argument index="0" replace-value="this"/>
+     <modify-argument index="0" replace-value="this"/>
 
 .. _parent:
 
 parent
 ^^^^^^
 
-    The ``parent`` node lets you define the argument parent which will
-    take ownership of argument and will destroy the C++ child object when the
-    parent is destroyed (see :ref:`ownership-parent`).
-    It is a child of the :ref:`modify-argument` node.
+The ``parent`` node lets you define the argument parent which will
+take ownership of argument and will destroy the C++ child object when the
+parent is destroyed (see :ref:`ownership-parent`).
+It is a child of the :ref:`modify-argument` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <modify-argument index="1">
-              <parent index="this" action="add | remove" />
-        </modify-argument>
+    <modify-argument index="1">
+          <parent index="this" action="add | remove" />
+    </modify-argument>
 
-    In the ``index`` argument you must specify the parent argument. The action
-    *add* creates a parent link between objects, while *remove* will undo the
-    parentage relationship.
+In the ``index`` argument you must specify the parent argument. The action
+*add* creates a parent link between objects, while *remove* will undo the
+parentage relationship.
diff --git a/sources/shiboken6/doc/typesystem_builtin_types.rst b/sources/shiboken6/doc/typesystem_builtin_types.rst
index ba9a576a6..dea253930 100644
--- a/sources/shiboken6/doc/typesystem_builtin_types.rst
+++ b/sources/shiboken6/doc/typesystem_builtin_types.rst
@@ -26,6 +26,20 @@ on platform.
 `std::string`, `std::wstring` and their associated view types
 `std::string_view`, `std::wstring_view` are also supported.
 
+
+.. _builtin-cpp-container-types:
+
+C++ Container Types
+^^^^^^^^^^^^^^^^^^^
+
+The C++ containers ``std::list``\, ``std::vector``\,
+``std::pair``\, ``std::map``\, ``std::span`` and ``std::unordered_map`` are
+built-in.
+To specify :ref:`opaque-containers`, use the :ref:`opaque-container` element.
+:ref:`container-type` can still be specified to modify the built-in behavior.
+For this case, a number of pre-defined conversion templates
+are provided (see :ref:`predefined_templates`).
+
 .. _cpython-types:
 
 CPython Types
diff --git a/sources/shiboken6/doc/typesystem_codeinjection.rst b/sources/shiboken6/doc/typesystem_codeinjection.rst
index 055e876a8..03d5f4b16 100644
--- a/sources/shiboken6/doc/typesystem_codeinjection.rst
+++ b/sources/shiboken6/doc/typesystem_codeinjection.rst
@@ -12,11 +12,11 @@ should be written to depends upon the technology used on the generated binding c
 
 This is the ``inject-code`` tag options that matters to |project|.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <inject-code class="native | target" position="beginning | end">
-             // custom code
-         </inject-code>
+     <inject-code class="native | target" position="beginning | end">
+         // custom code
+     </inject-code>
 
 
 inject-code tag
@@ -30,76 +30,79 @@ The ``position`` attribute specifies the location of the custom code in the
 function.
 
 
-    +---------------+------+-----------+--------------------------------------------------------------+
-    |Parent Tag     |Class |Position   |Meaning                                                       |
-    +===============+======+===========+==============================================================+
-    |value-type,    |native|beginning  |Write to the beginning of a class wrapper ``.cpp`` file, right|
-    |object-type    |      |           |after the ``#include`` clauses. A common use would be to write|
-    |               |      |           |prototypes for custom functions whose definitions are put on a|
-    |               |      |           |``native/end`` code injection.                                |
-    |               |      +-----------+--------------------------------------------------------------+
-    |               |      |end        |Write to the end of a class wrapper ``.cpp`` file. Could be   |
-    |               |      |           |used to write custom/helper functions definitions for         |
-    |               |      |           |prototypes declared on ``native/beginning``.                  |
-    |               +------+-----------+--------------------------------------------------------------+
-    |               |target|beginning  |Put custom code on the beginning of the wrapper initializer   |
-    |               |      |           |function (``init_CLASS(PyObject *module)``). This could be    |
-    |               |      |           |used to manipulate the ``PyCLASS_Type`` structure before      |
-    |               |      |           |registering it on Python.                                     |
-    |               |      +-----------+--------------------------------------------------------------+
-    |               |      |end        |Write the given custom code at the end of the class wrapper   |
-    |               |      |           |initializer function (``init_CLASS(PyObject *module)``). The  |
-    |               |      |           |code here will be executed after all the wrapped class        |
-    |               |      |           |components have been initialized.                             |
-    +---------------+------+-----------+--------------------------------------------------------------+
-    |modify-function|native|beginning  |Code here is put on the virtual method override of a C++      |
-    |               |      |           |wrapper class (the one responsible for passing C++ calls to a |
-    |               |      |           |Python override, if there is any), right after the C++        |
-    |               |      |           |arguments have been converted but before the Python call.     |
-    |               |      +-----------+--------------------------------------------------------------+
-    |               |      |end        |This code injection is put in a virtual method override on the|
-    |               |      |           |C++ wrapper class, after the call to Python and before        |
-    |               |      |           |dereferencing the Python method and tuple of arguments.       |
-    |               +------+-----------+--------------------------------------------------------------+
-    |               |target|beginning  |This code is injected on the Python method wrapper            |
-    |               |      |           |(``PyCLASS_METHOD(...)``), right after the decisor have found |
-    |               |      |           |which signature to call and also after the conversion of the  |
-    |               |      |           |arguments to be used, but before the actual call.             |
-    |               |      +-----------+--------------------------------------------------------------+
-    |               |      |end        |This code is injected on the Python method wrapper            |
-    |               |      |           |(``PyCLASS_METHOD(...)``), right after the C++ method call,   |
-    |               |      |           |but still inside the scope created by the overload for each   |
-    |               |      |           |signature.                                                    |
-    |               +------+-----------+--------------------------------------------------------------+
-    |               |shell |declaration|Used only for virtual functions. This code is injected at the |
-    |               |      |           |top.                                                          |
-    |               |      +-----------+--------------------------------------------------------------+
-    |               |      |beginning  |Used only for virtual functions. The code is injected when the|
-    |               |      |           |function does not has a Python implementation, then the code  |
-    |               |      |           |is inserted before c++ call                                   |
-    |               |      +-----------+--------------------------------------------------------------+
-    |               |      |end        |Same as above, but the code is inserted after c++ call        |
-    +---------------+------+-----------+--------------------------------------------------------------+
-    |typesystem     |native|beginning  |Write code to the beginning of the module ``.cpp`` file, right|
-    |               |      |           |after the ``#include`` clauses. This position has a similar   |
-    |               |      |           |purpose as the ``native/beginning`` position on a wrapper     |
-    |               |      |           |class ``.cpp`` file, namely write function prototypes, but not|
-    |               |      |           |restricted to this use.                                       |
-    |               |      +-----------+--------------------------------------------------------------+
-    |               |      |end        |Write code to the end of the module ``.cpp`` file. Usually    |
-    |               |      |           |implementations for function prototypes inserted at the       |
-    |               |      |           |beginning of the file with a ``native/beginning`` code        |
-    |               |      |           |injection.                                                    |
-    |               +------+-----------+--------------------------------------------------------------+
-    |               |target|beginning  |Insert code at the start of the module initialization function|
-    |               |      |           |(``initMODULENAME()``), before the calling ``Py_InitModule``. |
-    |               |      +-----------+--------------------------------------------------------------+
-    |               |      |end        |Insert code at the end of the module initialization function  |
-    |               |      |           |(``initMODULENAME()``), but before the checking that emits a  |
-    |               |      |           |fatal error in case of problems importing the module.         |
-    |               |      +-----------+--------------------------------------------------------------+
-    |               |      |declaration|Insert code into module header.                               |
-    +---------------+------+-----------+--------------------------------------------------------------+
++---------------+------+-----------+--------------------------------------------------------------+
+|Parent Tag     |Class |Position   |Meaning                                                       |
++===============+======+===========+==============================================================+
+|value-type,    |native|beginning  |Write to the beginning of a class wrapper ``.cpp`` file, right|
+|object-type    |      |           |after the ``#include`` clauses. A common use would be to write|
+|               |      |           |prototypes for custom functions whose definitions are put on a|
+|               |      |           |``native/end`` code injection.                                |
+|               |      +-----------+--------------------------------------------------------------+
+|               |      |end        |Write to the end of a class wrapper ``.cpp`` file. Could be   |
+|               |      |           |used to write custom/helper functions definitions for         |
+|               |      |           |prototypes declared on ``native/beginning``.                  |
+|               +------+-----------+--------------------------------------------------------------+
+|               |target|beginning  |Put custom code on the beginning of the wrapper initializer   |
+|               |      |           |function (``init_CLASS(PyObject *module)``). This could be    |
+|               |      |           |used to manipulate the ``PyCLASS_Type`` structure before      |
+|               |      |           |registering it on Python.                                     |
+|               |      +-----------+--------------------------------------------------------------+
+|               |      |end        |Write the given custom code at the end of the class wrapper   |
+|               |      |           |initializer function (``init_CLASS(PyObject *module)``). The  |
+|               |      |           |code here will be executed after all the wrapped class        |
+|               |      |           |components have been initialized.                             |
++---------------+------+-----------+--------------------------------------------------------------+
+|modify-function|native|beginning  |Code here is put on the virtual method override of a C++      |
+|               |      |           |wrapper class (the one responsible for passing C++ calls to a |
+|               |      |           |Python override, if there is any), right after the C++        |
+|               |      |           |arguments have been converted but before the Python call.     |
+|               |      +-----------+--------------------------------------------------------------+
+|               |      |end        |This code injection is put in a virtual method override on the|
+|               |      |           |C++ wrapper class, after the call to Python and before        |
+|               |      |           |dereferencing the Python method and tuple of arguments.       |
+|               +------+-----------+--------------------------------------------------------------+
+|               |target|beginning  |This code is injected on the Python method wrapper            |
+|               |      |           |(``PyCLASS_METHOD(...)``), right after the decisor have found |
+|               |      |           |which signature to call and also after the conversion of the  |
+|               |      |           |arguments to be used, but before the actual call.             |
+|               |      +-----------+--------------------------------------------------------------+
+|               |      |end        |This code is injected on the Python method wrapper            |
+|               |      |           |(``PyCLASS_METHOD(...)``), right after the C++ method call,   |
+|               |      |           |but still inside the scope created by the overload for each   |
+|               |      |           |signature.                                                    |
+|               +------+-----------+--------------------------------------------------------------+
+|               |shell |declaration|Used only for virtual functions. This code is injected at the |
+|               |      |           |top.                                                          |
+|               |      +-----------+--------------------------------------------------------------+
+|               |      |override   |Used only for virtual functions. The code is injected before  |
+|               |      |           |the code calling the Python override.                         |
+|               |      +-----------+--------------------------------------------------------------+
+|               |      |beginning  |Used only for virtual functions. The code is injected when the|
+|               |      |           |function does not has a Python implementation, then the code  |
+|               |      |           |is inserted before c++ call                                   |
+|               |      +-----------+--------------------------------------------------------------+
+|               |      |end        |Same as above, but the code is inserted after c++ call        |
++---------------+------+-----------+--------------------------------------------------------------+
+|typesystem     |native|beginning  |Write code to the beginning of the module ``.cpp`` file, right|
+|               |      |           |after the ``#include`` clauses. This position has a similar   |
+|               |      |           |purpose as the ``native/beginning`` position on a wrapper     |
+|               |      |           |class ``.cpp`` file, namely write function prototypes, but not|
+|               |      |           |restricted to this use.                                       |
+|               |      +-----------+--------------------------------------------------------------+
+|               |      |end        |Write code to the end of the module ``.cpp`` file. Usually    |
+|               |      |           |implementations for function prototypes inserted at the       |
+|               |      |           |beginning of the file with a ``native/beginning`` code        |
+|               |      |           |injection.                                                    |
+|               +------+-----------+--------------------------------------------------------------+
+|               |target|beginning  |Insert code at the start of the module initialization function|
+|               |      |           |(``initMODULENAME()``), before the calling ``Py_InitModule``. |
+|               |      +-----------+--------------------------------------------------------------+
+|               |      |end        |Insert code at the end of the module initialization function  |
+|               |      |           |(``initMODULENAME()``), but before the checking that emits a  |
+|               |      |           |fatal error in case of problems importing the module.         |
+|               |      +-----------+--------------------------------------------------------------+
+|               |      |declaration|Insert code into module header.                               |
++---------------+------+-----------+--------------------------------------------------------------+
 
 
 Anatomy of Code Injection
@@ -110,16 +113,16 @@ and the places where each kind of code injection goes.
 
 Below is the example C++ class for whom wrapper code will be generated.
 
-    .. code-block:: c++
+.. code-block:: c++
 
-        class InjectCode
-        {
-        public:
-            InjectCode();
-            double overloadedMethod(int arg);
-            double overloadedMethod(double arg);
-            virtual int virtualMethod(int arg);
-        };
+    class InjectCode
+    {
+    public:
+        InjectCode();
+        double overloadedMethod(int arg);
+        double overloadedMethod(double arg);
+        virtual int virtualMethod(int arg);
+    };
 
 From the C++ class, |project| will generate a ``injectcode_wrapper.cpp`` file
 with the binding code. The next section will use a simplified version of the
@@ -168,21 +171,21 @@ of writing the actual name of the wrapped method/function.
 
 In other words, use
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <inject-code class="target" position="beginning | end">
-             %CPPSELF.originalMethodName();
-         </inject-code>
+     <inject-code class="target" position="beginning | end">
+         %CPPSELF.originalMethodName();
+     </inject-code>
 
 
 instead of
 
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <inject-code class="target" position="beginning | end">
-            %CPPSELF.%FUNCTION_NAME();
-         </inject-code>
+     <inject-code class="target" position="beginning | end">
+        %CPPSELF.%FUNCTION_NAME();
+     </inject-code>
 
 
 Code Injection for Functions/Methods
@@ -197,30 +200,30 @@ On The Native Side
 Notice that this is only used when there is a C++ wrapper, i.e. the wrapped
 class is polymorphic.
 
-    .. code-block:: c++
+.. code-block:: c++
 
-        int InjectCodeWrapper::virtualMethod(int arg)
-        {
-            PyObject *method = BindingManager::instance().getOverride(this, "virtualMethod");
-            if (!py_override)
-                return this->InjectCode::virtualMethod(arg);
+    int InjectCodeWrapper::virtualMethod(int arg)
+    {
+        PyObject *method = BindingManager::instance().getOverride(this, "virtualMethod");
+        if (!py_override)
+            return this->InjectCode::virtualMethod(arg);
 
-            (... here C++ arguments are converted to Python ...)
+        (... here C++ arguments are converted to Python ...)
 
-            // INJECT-CODE: <modify-function><inject-code class="native" position="beginning">
-            // Uses: pre method call custom code, modify the argument before the
-            // Python call.
+        // INJECT-CODE: <modify-function><inject-code class="native" position="beginning">
+        // Uses: pre method call custom code, modify the argument before the
+        // Python call.
 
-            (... Python method call goes in here ...)
+        (... Python method call goes in here ...)
 
-            // INJECT-CODE: <modify-function><inject-code class="native" position="end">
-            // Uses: post method call custom code, modify the result before delivering
-            // it to C++ caller.
+        // INJECT-CODE: <modify-function><inject-code class="native" position="end">
+        // Uses: post method call custom code, modify the result before delivering
+        // it to C++ caller.
 
-            (... Python method and argument tuple are dereferenced here ...)
+        (... Python method and argument tuple are dereferenced here ...)
 
-            return Shiboken::Converter<int>::toCpp(method_result);
-        }
+        return Shiboken::Converter<int>::toCpp(method_result);
+    }
 
 
 On The Target Side
@@ -231,37 +234,37 @@ method that uses an overload decisor to call the correct C++ method based on the
 arguments passed by the Python call. Each overloaded method signature has its
 own ``beginning`` and ``end`` code injections.
 
-    .. code-block:: c++
+.. code-block:: c++
 
-            static PyObject *PyInjectCode_overloadedMethod(PyObject *self, PyObject *arg)
-            {
-                PyObject* py_result{};
-                if (PyFloat_Check(arg)) {
-                    double cpp_arg0 = Shiboken::Converter<double >::toCpp(arg);
+        static PyObject *PyInjectCode_overloadedMethod(PyObject *self, PyObject *arg)
+        {
+            PyObject* py_result{};
+            if (PyFloat_Check(arg)) {
+                double cpp_arg0 = Shiboken::Converter<double >::toCpp(arg);
 
-                    // INJECT-CODE: <modify-function><inject-code class="target" position="beginning">
-                    // Uses: pre method call custom code.
+                // INJECT-CODE: <modify-function><inject-code class="target" position="beginning">
+                // Uses: pre method call custom code.
 
-                    py_result = Shiboken::Converter<double >::toPython(
-                        PyInjectCode_cptr(self)->InjectCode::overloadedMethod(cpp_arg0)
-                    );
+                py_result = Shiboken::Converter<double >::toPython(
+                    PyInjectCode_cptr(self)->InjectCode::overloadedMethod(cpp_arg0)
+                );
 
-                    // INJECT-CODE: <modify-function><inject-code class="target" position="end">
-                    // Uses: post method call custom code.
+                // INJECT-CODE: <modify-function><inject-code class="target" position="end">
+                // Uses: post method call custom code.
 
-                } else if (PyNumber_Check(arg)) {
-                    (... other overload calling code ...)
-                } else goto PyInjectCode_overloadedMethod_TypeError;
+            } else if (PyNumber_Check(arg)) {
+                (... other overload calling code ...)
+            } else goto PyInjectCode_overloadedMethod_TypeError;
 
-                if (PyErr_Occurred() || !py_result)
-                    return {};
+            if (PyErr_Occurred() || !py_result)
+                return {};
 
-                return py_result;
+            return py_result;
 
-                PyInjectCode_overloadedMethod_TypeError:
-                    PyErr_SetString(PyExc_TypeError, "'overloadedMethod()' called with wrong parameters.");
-                    return {};
-            }
+            PyInjectCode_overloadedMethod_TypeError:
+                PyErr_SetString(PyExc_TypeError, "'overloadedMethod()' called with wrong parameters.");
+                return {};
+        }
 
 
 .. _codeinjecting_classes:
@@ -277,35 +280,35 @@ On The Native Side
 Those injections go in the body of the ``CLASSNAME_wrapper.cpp`` file for the
 wrapped class.
 
-    .. code-block:: c++
+.. code-block:: c++
 
-        // Start of ``CLASSNAME_wrapper.cpp``
-        #define protected public
-        // default includes
-        #include <shiboken.h>
-        (...)
-        #include "injectcode_wrapper.h"
-        using namespace Shiboken;
-
-        // INJECT-CODE: <value/object-type><inject-code class="native" position="beginning">
-        // Uses: prototype declarations
+    // Start of ``CLASSNAME_wrapper.cpp``
+    #define protected public
+    // default includes
+    #include <shiboken.h>
+    (...)
+    #include "injectcode_wrapper.h"
+    using namespace Shiboken;
 
-        (... C++ wrapper virtual methods, if any ...)
+    // INJECT-CODE: <value/object-type><inject-code class="native" position="beginning">
+    // Uses: prototype declarations
 
-        (... Python wrapper code ...)
+    (... C++ wrapper virtual methods, if any ...)
 
-        PyAPI_FUNC(void)
-        init_injectcode(PyObject *module)
-        {
-            (...)
-        }
+    (... Python wrapper code ...)
 
+    PyAPI_FUNC(void)
+    init_injectcode(PyObject *module)
+    {
         (...)
+    }
 
-        // INJECT-CODE: <value/object-type><inject-code class="native" position="end">
-        // Uses: definition of functions prototyped at ``native/beginning``.
+    (...)
 
-        // End of ``CLASSNAME_wrapper.cpp``
+    // INJECT-CODE: <value/object-type><inject-code class="native" position="end">
+    // Uses: definition of functions prototyped at ``native/beginning``.
+
+    // End of ``CLASSNAME_wrapper.cpp``
 
 
 .. _codeinjecting_classes_target:
@@ -315,34 +318,34 @@ On The Target Side
 
 Code injections to the class Python initialization function.
 
-    .. code-block:: c++
+.. code-block:: c++
 
-        // Start of ``CLASSNAME_wrapper.cpp``
+    // Start of ``CLASSNAME_wrapper.cpp``
 
-        (...)
+    (...)
 
-        PyAPI_FUNC(void)
-        init_injectcode(PyObject *module)
-        {
-            // INJECT-CODE: <value/object-type><inject-code class="target" position="beginning">
-            // Uses: Alter something in the PyInjectCode_Type (tp_flags value for example)
-            // before registering it.
+    PyAPI_FUNC(void)
+    init_injectcode(PyObject *module)
+    {
+        // INJECT-CODE: <value/object-type><inject-code class="target" position="beginning">
+        // Uses: Alter something in the PyInjectCode_Type (tp_flags value for example)
+        // before registering it.
 
-            if (PyType_Ready(&PyInjectCode_Type) < 0)
-                return;
+        if (PyType_Ready(&PyInjectCode_Type) < 0)
+            return;
 
-            Py_INCREF(&PyInjectCode_Type);
-            PyModule_AddObject(module, "InjectCode",
-                ((PyObject*)&PyInjectCode_Type));
+        Py_INCREF(&PyInjectCode_Type);
+        PyModule_AddObject(module, "InjectCode",
+            ((PyObject*)&PyInjectCode_Type));
 
-            // INJECT-CODE: <value/object-type><inject-code class="target" position="end">
-            // Uses: do something right after the class is registered, like set some static
-            // variable injected on this same file elsewhere.
-        }
+        // INJECT-CODE: <value/object-type><inject-code class="target" position="end">
+        // Uses: do something right after the class is registered, like set some static
+        // variable injected on this same file elsewhere.
+    }
 
-        (...)
+    (...)
 
-        // End of ``CLASSNAME_wrapper.cpp``
+    // End of ``CLASSNAME_wrapper.cpp``
 
 Code Injection for Modules
 ==========================
@@ -365,30 +368,30 @@ This is very similar to class wrapper code injections :ref:`codeinjecting_classe
 Notice that the inject code at ``target/end`` is inserted before the check for errors
 to prevent bad custom code to pass unnoticed.
 
-    .. code-block:: c++
+.. code-block:: c++
 
-        // Start of ``MODULENAME_module_wrapper.cpp``
+    // Start of ``MODULENAME_module_wrapper.cpp``
 
-        (...)
-        initMODULENAME()
-        {
-            // INJECT-CODE: <typesystem><inject-code class="target" position="beginning">
-            // Uses: do something before the module is created.
+    (...)
+    initMODULENAME()
+    {
+        // INJECT-CODE: <typesystem><inject-code class="target" position="beginning">
+        // Uses: do something before the module is created.
 
-            PyObject *module = Py_InitModule("MODULENAME", MODULENAME_methods);
+        PyObject *module = Py_InitModule("MODULENAME", MODULENAME_methods);
 
-            (... initialization of wrapped classes, namespaces, functions and enums ...)
+        (... initialization of wrapped classes, namespaces, functions and enums ...)
 
-            // INJECT-CODE: <typesystem><inject-code class="target" position="end">
-            // Uses: do something after the module is registered and initialized.
+        // INJECT-CODE: <typesystem><inject-code class="target" position="end">
+        // Uses: do something after the module is registered and initialized.
 
-            if (PyErr_Occurred())
-                Py_FatalError("can't initialize module sample");
-        }
+        if (PyErr_Occurred())
+            Py_FatalError("can't initialize module sample");
+    }
 
-        (...)
+    (...)
 
-        // Start of ``MODULENAME_module_wrapper.cpp``
+    // Start of ``MODULENAME_module_wrapper.cpp``
 
 In addition, code can be injected into the module header by specifying ``target``
 and ``declaration``. This is useful for type definitions.
diff --git a/sources/shiboken6/doc/typesystem_containers.rst b/sources/shiboken6/doc/typesystem_containers.rst
index 5c4abee44..b5593e20f 100644
--- a/sources/shiboken6/doc/typesystem_containers.rst
+++ b/sources/shiboken6/doc/typesystem_containers.rst
@@ -19,7 +19,8 @@ instead of a Python list. Manipulations like adding or removing elements
 can applied directly to them using the C++ container functions.
 
 This is achieved by specifying the name and the instantiated type
-in the ``opaque-containers`` attribute of :ref:`container-type`.
+in the ``opaque-containers`` attribute of :ref:`container-type`
+or using the :ref:`opaque-container` element for existing container types.
 
 A second use case are public fields of container types. In the normal case,
 they are converted to Python containers on read access. By a field modification,
@@ -34,41 +35,50 @@ The table below lists the functions supported for opaque sequence containers
 besides the sequence protocol (element access via index and ``len()``). Both
 the STL and the Qt naming convention (which resembles Python's) are supported:
 
-    +-------------------------------------------+-----------------------------------+
-    |Function                                   | Description                       |
-    +-------------------------------------------+-----------------------------------+
-    | ``push_back(value)``, ``append(value)``   | Appends *value* to the sequence.  |
-    +-------------------------------------------+-----------------------------------+
-    | ``push_front(value)``, ``prepend(value)`` | Prepends *value* to the sequence. |
-    +-------------------------------------------+-----------------------------------+
-    | ``clear()``                               | Clears the sequence.              |
-    +-------------------------------------------+-----------------------------------+
-    | ``pop_back()``, ``removeLast()``          | Removes the last element.         |
-    +-------------------------------------------+-----------------------------------+
-    | ``pop_front()``, ``removeFirst()``        | Removes the first element.        |
-    +-------------------------------------------+-----------------------------------+
-    | ``reserve(size)``                         | For containers that support it    |
-    |                                           | (``std::vector``, ``QList``),     |
-    |                                           | allocate memory for at least      |
-    |                                           | ``size`` elements, preventing     |
-    |                                           | reallocations.                    |
-    +-------------------------------------------+-----------------------------------+
-    | ``capacity()``                            | For containers that support it    |
-    |                                           | (``std::vector``, ``QList``),     |
-    |                                           | return the number of elements     |
-    |                                           | that can be stored without        |
-    |                                           | reallocation.                     |
-    +-------------------------------------------+-----------------------------------+
-    | ``data()``                                | For containers that support it    |
-    |                                           | (``std::vector``, ``QList``),     |
-    |                                           | return a buffer viewing the       |
-    |                                           | memory.                           |
-    +-------------------------------------------+-----------------------------------+
-    | ``constData()``                           | For containers that support it    |
-    |                                           | (``std::vector``, ``QList``),     |
-    |                                           | return a read-only buffer viewing |
-    |                                           | the memory.                       |
-    +-------------------------------------------+-----------------------------------+
++-------------------------------------------+-----------------------------------+
+|Function                                   | Description                       |
++-------------------------------------------+-----------------------------------+
+| ``push_back(value)``, ``append(value)``   | Appends *value* to the sequence.  |
++-------------------------------------------+-----------------------------------+
+| ``push_front(value)``, ``prepend(value)`` | Prepends *value* to the sequence. |
++-------------------------------------------+-----------------------------------+
+| ``clear()``                               | Clears the sequence.              |
++-------------------------------------------+-----------------------------------+
+| ``pop_back()``, ``removeLast()``          | Removes the last element.         |
++-------------------------------------------+-----------------------------------+
+| ``pop_front()``, ``removeFirst()``        | Removes the first element.        |
++-------------------------------------------+-----------------------------------+
+| ``reserve(size)``                         | For containers that support it    |
+|                                           | (``std::vector``, ``QList``),     |
+|                                           | allocate memory for at least      |
+|                                           | ``size`` elements, preventing     |
+|                                           | reallocations.                    |
++-------------------------------------------+-----------------------------------+
+| ``capacity()``                            | For containers that support it    |
+|                                           | (``std::vector``, ``QList``),     |
+|                                           | return the number of elements     |
+|                                           | that can be stored without        |
+|                                           | reallocation.                     |
++-------------------------------------------+-----------------------------------+
+| ``data()``                                | For containers that support it    |
+|                                           | (``std::vector``, ``QList``),     |
+|                                           | return a buffer viewing the       |
+|                                           | memory.                           |
++-------------------------------------------+-----------------------------------+
+| ``constData()``                           | For containers that support it    |
+|                                           | (``std::vector``, ``QList``),     |
+|                                           | return a read-only buffer viewing |
+|                                           | the memory.                       |
++-------------------------------------------+-----------------------------------+
+
+
+.. note:: ``std::span``, being a non-owning container, is currently replaced by a
+          ``std::vector`` for argument passing. This means that an opaque container
+          wrapping a ``std::span`` obtained from a function will be converted
+          to a ``std::vector`` by sequence conversion when passed to a function
+          taking a ``std::span``.
+          Opaque containers wrapping a ``std::vector`` can be passed without conversion.
+          This is currently experimental and subject to change.
 
 Following is an example on creating an opaque container named ``IntVector``
 from `std::vector<int>`, and using it in Python.
@@ -76,7 +86,7 @@ from `std::vector<int>`, and using it in Python.
 We will consider three separate use cases.
 
 **Case 1** - When a Python list is passed to C++ function
-`TestOpaqueContainer.getVectorSum(const std::vector<int>&)` as an opaque container
+``TestOpaqueContainer.getVectorSum(const std::vector<int>&)`` as an opaque container
 
 .. code-block:: c
 
@@ -89,7 +99,7 @@ We will consider three separate use cases.
         }
     };
 
-**Case 2** - When we have a C++ class named `TestOpaqueContainer` with a `std::vector<int>`
+**Case 2** - When we have a C++ class named ``TestOpaqueContainer`` with a ``std::vector<int>``
 public variable
 
 .. code-block:: c
@@ -101,7 +111,7 @@ public variable
 
     };
 
-**Case 3** - When we have a C++ class named `TestOpaqueContainer` with a `std::vector<int>` as
+**Case 3** - When we have a C++ class named ``TestOpaqueContainer`` with a ``std::vector<int>`` as
 private variable and the variable is returned by a reference through a getter.
 
 .. code-block:: c
@@ -123,9 +133,9 @@ private variable and the variable is returned by a reference through a getter.
           of these examples are rather to show the different possibilities with opaque containers in
           Shiboken than the class design.
 
-In all the three cases, we want to use `intVector` in Python through an opaque-container. The
-first thing to do is to create the corresponding `<container-type />` attribute in the typesystem
-file, making Shiboken aware of the `IntVector`.
+In all the three cases, we want to use ``intVector`` in Python through an opaque-container. The
+first thing to do is to create the corresponding ``<container-type />`` attribute in the typesystem
+file, making Shiboken aware of the ``IntVector``.
 
 .. code-block:: xml
 
@@ -147,17 +157,17 @@ For the rest of the steps, we consider the three cases separately.
 
 **Case 1** - When a Python list is passed to a C++ function
 
-As the next step, we create a typesystem entry for the class `TestOpaqueContainer`.
+As the next step, we create a typesystem entry for the class ``TestOpaqueContainer``.
 
 .. code-block:: xml
 
     <value-type name="TestOpaqueContainer" />
 
 In this case, the typesystem entry is simple and the function
-`getVectorSum(const std::vector<int>&)` accepts `IntVector` as the parameter. This is
-because inherantly `IntVector` is the same as `std::vector<int>`.
+``getVectorSum(const std::vector<int>&)`` accepts ``IntVector`` as the parameter. This is
+because inherantly ``IntVector`` is the same as ``std::vector<int>``.
 
-Now, build the code to create the \*_wrapper.cpp and \*.so files which we import into Python.
+Now, build the code to create the ``*_wrapper.cpp`` and ``*.so`` files which we import into Python.
 
 Verifying the usage in Python
 
@@ -173,7 +183,7 @@ Verifying the usage in Python
 
 **Case 2** - When the variable is public
 
-We create a typesystem entry for the class `TestOpaqueContainer`.
+We create a typesystem entry for the class ``TestOpaqueContainer``.
 
 .. code-block:: xml
 
@@ -181,11 +191,11 @@ We create a typesystem entry for the class `TestOpaqueContainer`.
         <modify-field name="intVector" opaque-container="yes"/>
     </value-type>
 
-In the `<modify-field />` notice the `opaque-container="yes"`. Since the type
-of `intVector' is `std::vector<int>`, it picks up the ``IntVector`` opaque
+In the ``<modify-field />`` notice the ``opaque-container="yes"``. Since the type
+of ``intVector`` is ``std::vector<int>``, it picks up the ``IntVector`` opaque
 container.
 
-Build the code to create the \*_wrapper.cpp and \*.so files which we import into Python.
+Build the code to create the ``*_wrapper.cpp`` and ``*.so`` files which we import into Python.
 
 Verifying the usage in Python
 
@@ -206,7 +216,7 @@ Verifying the usage in Python
 
 **Case 3** - When the variable is private and returned by reference through a getter
 
-Similar to the previous cases, we create a typesystem entry for the class `TestOpaqueContainer`.
+Similar to the previous cases, we create a typesystem entry for the class ``TestOpaqueContainer``.
 
 .. code-block:: xml
 
@@ -218,7 +228,7 @@ Similar to the previous cases, we create a typesystem entry for the class `TestO
         </modify-function>
     </value-type>
 
-In this case, we specify the name of the opaque container `IntVector` in the <replace-type />
+In this case, we specify the name of the opaque container ``IntVector`` in the ``<replace-type />``
 field.
 
 Build the code to create the \*_wrapper.cpp and \*.so files which we import into Python.
diff --git a/sources/shiboken6/doc/typesystem_conversionrule.rst b/sources/shiboken6/doc/typesystem_conversionrule.rst
index 4ac2bd365..9a8f51c18 100644
--- a/sources/shiboken6/doc/typesystem_conversionrule.rst
+++ b/sources/shiboken6/doc/typesystem_conversionrule.rst
@@ -8,99 +8,99 @@ Conversion Rule Tag
 conversion-rule
 ^^^^^^^^^^^^^^^
 
-    The **conversion-rule** tag specifies how a **primitive-type**, a **container-type**,
-    or a **value-type** may be converted to and from the native C++ language types to the
-    target language types (see also :ref:`user-defined-type-conversion`).
-
-    It is a child of the :ref:`container-type`, :ref:`primitive-type` or
-    :ref:`value-type` and may contain :ref:`native-to-target` or
-    :ref:`native-to-target` child nodes.
-
-    .. code-block:: xml
-
-        <value-type>
-            <conversion-rule>
-                <native-to-target>
-                // Code to convert a native value to a target language object.
-                </native-to-target>
-                <target-to-native>
-                    <add-conversion type='TARGETTYPEA' check='TARGETTYPEA_CHECK(%in)'>
-                    // Code to convert target language type object of type TARGETTYPEA
-                    // to the C++ native type represented by the value/primitive/container-type.
-                    </add-conversion>
-                    <add-conversion type='TARGETTYPEB' check='TARGETTYPEB_CHECK(%in)'>
-                    // Code to convert target language type object of type TARGETTYPEB
-                    // to the C++ native type represented by the value/primitive/container-type.
-                    </add-conversion>
-                </target-to-native>
-            </conversion-rule>
-        </value-type>
-
-    The code can be inserted directly, via :ref:`add-conversion` (providing snippet
-    functionality) or via :ref:`insert-template` (XML template,
-    see :ref:`using-code-templates`).
-
-    The example above show the structure of a complete conversion rule. Each of the
-    child tags comprising the conversion rule are described in their own sections
-    below.
-
-    .. note::
-
-        You can also use the ``conversion-rule`` node to specify customized code
-        to convert a function argument between the target language and C++
-        (see :ref:`conversionrule-on-arguments`).
+The **conversion-rule** tag specifies how a **primitive-type**, a **container-type**,
+or a **value-type** may be converted to and from the native C++ language types to the
+target language types (see also :ref:`user-defined-type-conversion`).
 
-.. _native-to-target:
-
-native-to-target
-^^^^^^^^^^^^^^^^
-
-    The **native-to-target** tag tells how to convert a native C++ value to its
-    target language equivalent. It is a child of the :ref:`conversion-rule` node.
-    The text inside the tag is a C++ code the takes
-    an input value an does what's needed to convert it to the output value.
-    :ref:`insert-template` tags may be used to insert commonly repeating code.
+It is a child of the :ref:`container-type`, :ref:`primitive-type` or
+:ref:`value-type` and may contain :ref:`native-to-target` or
+:ref:`native-to-target` child nodes.
 
-    .. code-block:: xml
+.. code-block:: xml
 
+    <value-type>
         <conversion-rule>
             <native-to-target>
             // Code to convert a native value to a target language object.
             </native-to-target>
+            <target-to-native>
+                <add-conversion type='TARGETTYPEA' check='TARGETTYPEA_CHECK(%in)'>
+                // Code to convert target language type object of type TARGETTYPEA
+                // to the C++ native type represented by the value/primitive/container-type.
+                </add-conversion>
+                <add-conversion type='TARGETTYPEB' check='TARGETTYPEB_CHECK(%in)'>
+                // Code to convert target language type object of type TARGETTYPEB
+                // to the C++ native type represented by the value/primitive/container-type.
+                </add-conversion>
+            </target-to-native>
         </conversion-rule>
+    </value-type>
 
-    Use the replace node to modify the template code.
-    Notice that the generator must provide type system variables for the input
-    and output values and types, namely **%in**, **%out**, **%INTYPE** and
-    **%OUTTYPE**. In the case of container types, **%INTYPE** refers to the
-    full container type (e.g. **"list<int>"**) and **%INTYPE_0**, **%INTYPE_1**,
-    **%INTYPE_#**, should be replaced by the types used in the container template
-    (e.g. **%INTYPE_0** correspondes to **"int"** for **"list<int>"**).
+The code can be inserted directly, via :ref:`add-conversion` (providing snippet
+functionality) or via :ref:`insert-template` (XML template,
+see :ref:`using-code-templates`).
 
-    The ``file`` and ``snippet`` attributes are also supported (see :ref:`inject-code` nodes).
+The example above show the structure of a complete conversion rule. Each of the
+child tags comprising the conversion rule are described in their own sections
+below.
+
+.. note::
+
+    You can also use the ``conversion-rule`` node to specify customized code
+    to convert a function argument between the target language and C++
+    (see :ref:`conversionrule-on-arguments`).
+
+.. _native-to-target:
+
+native-to-target
+^^^^^^^^^^^^^^^^
+
+The **native-to-target** tag tells how to convert a native C++ value to its
+target language equivalent. It is a child of the :ref:`conversion-rule` node.
+The text inside the tag is a C++ code the takes
+an input value an does what's needed to convert it to the output value.
+:ref:`insert-template` tags may be used to insert commonly repeating code.
+
+.. code-block:: xml
+
+    <conversion-rule>
+        <native-to-target>
+        // Code to convert a native value to a target language object.
+        </native-to-target>
+    </conversion-rule>
+
+Use the replace node to modify the template code.
+Notice that the generator must provide type system variables for the input
+and output values and types, namely **%in**, **%out**, **%INTYPE** and
+**%OUTTYPE**. In the case of container types, **%INTYPE** refers to the
+full container type (e.g. **"list<int>"**) and **%INTYPE_0**, **%INTYPE_1**,
+**%INTYPE_#**, should be replaced by the types used in the container template
+(e.g. **%INTYPE_0** correspondes to **"int"** for **"list<int>"**).
+
+The ``file`` and ``snippet`` attributes are also supported (see :ref:`inject-code` nodes).
 
 .. _target-to-native:
 
 target-to-native
 ^^^^^^^^^^^^^^^^
 
-    The **target-to-native** tag encloses at least one, but usually many, conversions
-    from target language values to C++ native values. It is a child of the
-    :ref:`conversion-rule` node and may have one or several :ref:`add-conversion`
-    child nodes. The *optional* attribute ``replace`` tells if the target
-    language to C++ conversions will be added to, or if they will replace the
-    implicit conversions collected by *ApiExtractor*. The default
-    value for it is *yes*.
+The **target-to-native** tag encloses at least one, but usually many, conversions
+from target language values to C++ native values. It is a child of the
+:ref:`conversion-rule` node and may have one or several :ref:`add-conversion`
+child nodes. The *optional* attribute ``replace`` tells if the target
+language to C++ conversions will be added to, or if they will replace the
+implicit conversions collected by *ApiExtractor*. The default
+value for it is *yes*.
 
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <conversion-rule>
-            <target-to-native replace='yes|no'>\
-            // List of target to native conversions meant to replace or expand
-            // the already existing implicit conversions.
-            </target-to-native>
-        </conversion-rule>
+    <conversion-rule>
+        <target-to-native replace='yes|no'>
+        // List of target to native conversions meant to replace or expand
+        // the already existing implicit conversions.
+        </target-to-native>
+    </conversion-rule>
 
 
 .. _add-conversion:
@@ -108,26 +108,26 @@ target-to-native
 add-conversion
 ^^^^^^^^^^^^^^
 
-    Each **add-conversion** tag adds a rule for conversion of a target language type,
-    indicated by the ``type`` attribute, to the C++ native type represented by the
-    **primitive-type**, a **container-type**, or **value-type**, to which the parent
-    **conversion-rule** belongs.
-    It is a child of the :ref:`target-to-native` node.
+Each **add-conversion** tag adds a rule for conversion of a target language type,
+indicated by the ``type`` attribute, to the C++ native type represented by the
+**primitive-type**, a **container-type**, or **value-type**, to which the parent
+**conversion-rule** belongs.
+It is a child of the :ref:`target-to-native` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <target-to-native>
-            <add-conversion type='TARGETTYPE' check='TARGETTYPECHECK(%in)'>
-            // Code to convert target language type object of type TARGETTYPE_A
-            // to the C++ native type represented by the value/primitive/container-type.
-            </add-conversion>
-        <target-to-native>
+    <target-to-native>
+        <add-conversion type='TARGETTYPE' check='TARGETTYPECHECK(%in)'>
+        // Code to convert target language type object of type TARGETTYPE_A
+        // to the C++ native type represented by the value/primitive/container-type.
+        </add-conversion>
+    <target-to-native>
 
-   The ``check`` attribute tells how a target value should be checked to see if it belongs to
-   the type expected. This attribute is *optional*, for it can be derived from the ``type``
-   attribute, but it isn't unusual that some special check is needed. The variables
-   **%in**, **%out**, **%INTYPE**, **%INTYPE_#**, and **%OUTTYPE**, must be provided by
-   the generator as in the ``native-to-target`` tag.
+The ``check`` attribute tells how a target value should be checked to see if it belongs to
+the type expected. This attribute is *optional*, for it can be derived from the ``type``
+attribute, but it isn't unusual that some special check is needed. The variables
+**%in**, **%out**, **%INTYPE**, **%INTYPE_#**, and **%OUTTYPE**, must be provided by
+the generator as in the ``native-to-target`` tag.
 
-   The ``file`` and ``snippet`` attributes are also supported (see :ref:`inject-code` nodes).
+The ``file`` and ``snippet`` attributes are also supported (see :ref:`inject-code` nodes).
 
diff --git a/sources/shiboken6/doc/typesystem_converters.rst b/sources/shiboken6/doc/typesystem_converters.rst
index 02600e7b1..ab6fba930 100644
--- a/sources/shiboken6/doc/typesystem_converters.rst
+++ b/sources/shiboken6/doc/typesystem_converters.rst
@@ -12,51 +12,51 @@ numbers, has a Python equivalent in the "complex" type.) Such classes, instead
 of getting a Python wrapper, normally have conversions rules, from Python to
 C++ and vice-versa.
 
-      .. code-block:: c++
+.. code-block:: c++
 
-          // C++ class
-          struct Complex {
-              Complex(double real, double imag);
-              double real() const;
-              double imag() const;
-          };
+    // C++ class
+    struct Complex {
+        Complex(double real, double imag);
+        double real() const;
+        double imag() const;
+    };
 
-          // Converting from C++ to Python using the CPython API:
-          PyObject* pyCpxObj = PyComplex_FromDoubles(complex.real(), complex.imag());
+    // Converting from C++ to Python using the CPython API:
+    PyObject* pyCpxObj = PyComplex_FromDoubles(complex.real(), complex.imag());
 
-          // Converting from Python to C++:
-          double real = PyComplex_RealAsDouble(pyCpxObj);
-          double imag = PyComplex_ImagAsDouble(pyCpxObj);
-          Complex cpx(real, imag);
+    // Converting from Python to C++:
+    double real = PyComplex_RealAsDouble(pyCpxObj);
+    double imag = PyComplex_ImagAsDouble(pyCpxObj);
+    Complex cpx(real, imag);
 
 
 For the user defined conversion code to be inserted in the proper places,
 the :ref:`conversion-rule` tag must be used.
 
-      .. code-block:: xml
+.. code-block:: xml
 
-        <primitive-type name="Complex" target-lang-api-name="PyComplex">
-          <include file-name="complex.h" location="global"/>
+  <primitive-type name="Complex" target-lang-api-name="PyComplex">
+    <include file-name="complex.h" location="global"/>
 
-          <conversion-rule>
+    <conversion-rule>
 
-            <native-to-target>
-            return PyComplex_FromDoubles(%in.real(), %in.imag());
-            </native-to-target>
+      <native-to-target>
+      return PyComplex_FromDoubles(%in.real(), %in.imag());
+      </native-to-target>
 
-            <target-to-native>
-              <!-- The 'check' attribute can be derived from the 'type' attribute,
-                   it is defined here to test the CHECKTYPE type system variable. -->
-              <add-conversion type="PyComplex" check="%CHECKTYPE[Complex](%in)">
-              double real = PyComplex_RealAsDouble(%in);
-              double imag = PyComplex_ImagAsDouble(%in);
-              %out = %OUTTYPE(real, imag);
-              </add-conversion>
-            </target-to-native>
+      <target-to-native>
+        <!-- The 'check' attribute can be derived from the 'type' attribute,
+             it is defined here to test the CHECKTYPE type system variable. -->
+        <add-conversion type="PyComplex" check="%CHECKTYPE[Complex](%in)">
+        double real = PyComplex_RealAsDouble(%in);
+        double imag = PyComplex_ImagAsDouble(%in);
+        %out = %OUTTYPE(real, imag);
+        </add-conversion>
+      </target-to-native>
 
-          </conversion-rule>
+    </conversion-rule>
 
-        </primitive-type>
+  </primitive-type>
 
 
 The details will be given later, but the gist of it are the tags
@@ -78,53 +78,53 @@ of numbers to be accepted by wrapped C++ functions with "Complex" arguments,
 an :ref:`add-conversion <add-conversion>` tag and a custom check must be added.
 Here's how to do it:
 
-      .. code-block:: xml
+.. code-block:: xml
 
-        <!-- Code injection at module level. -->
-        <inject-code class="native" position="beginning">
-        static bool Check2TupleOfNumbers(PyObject* pyIn) {
-            if (!PySequence_Check(pyIn) || !(PySequence_Size(pyIn) == 2))
-                return false;
-            Shiboken::AutoDecRef pyReal(PySequence_GetItem(pyIn, 0));
-            if (!PyNumber_Check(pyReal))
-                return false;
-            Shiboken::AutoDecRef pyImag(PySequence_GetItem(pyIn, 1));
-            if (!PyNumber_Check(pyImag))
-                return false;
-            return true;
-        }
-        </inject-code>
+  <!-- Code injection at module level. -->
+  <inject-code class="native" position="beginning">
+  static bool Check2TupleOfNumbers(PyObject* pyIn) {
+      if (!PySequence_Check(pyIn) || !(PySequence_Size(pyIn) == 2))
+          return false;
+      Shiboken::AutoDecRef pyReal(PySequence_GetItem(pyIn, 0));
+      if (!PyNumber_Check(pyReal))
+          return false;
+      Shiboken::AutoDecRef pyImag(PySequence_GetItem(pyIn, 1));
+      if (!PyNumber_Check(pyImag))
+          return false;
+      return true;
+  }
+  </inject-code>
 
-        <primitive-type name="Complex" target-lang-api-name="PyComplex">
-          <include file-name="complex.h" location="global"/>
+  <primitive-type name="Complex" target-lang-api-name="PyComplex">
+    <include file-name="complex.h" location="global"/>
 
-          <conversion-rule>
+    <conversion-rule>
 
-            <native-to-target>
-            return PyComplex_FromDoubles(%in.real(), %in.imag());
-            </native-to-target>
+      <native-to-target>
+      return PyComplex_FromDoubles(%in.real(), %in.imag());
+      </native-to-target>
 
-            <target-to-native>
+      <target-to-native>
 
-              <add-conversion type="PyComplex">
-              double real = PyComplex_RealAsDouble(%in);
-              double imag = PyComplex_ImagAsDouble(%in);
-              %out = %OUTTYPE(real, imag);
-              </add-conversion>
+        <add-conversion type="PyComplex">
+        double real = PyComplex_RealAsDouble(%in);
+        double imag = PyComplex_ImagAsDouble(%in);
+        %out = %OUTTYPE(real, imag);
+        </add-conversion>
 
-              <add-conversion type="PySequence" check="Check2TupleOfNumbers(%in)">
-              Shiboken::AutoDecRef pyReal(PySequence_GetItem(%in, 0));
-              Shiboken::AutoDecRef pyImag(PySequence_GetItem(%in, 1));
-              double real = %CONVERTTOCPP[double](pyReal);
-              double imag  = %CONVERTTOCPP[double](pyImag);
-              %out = %OUTTYPE(real, imag);
-              </add-conversion>
+        <add-conversion type="PySequence" check="Check2TupleOfNumbers(%in)">
+        Shiboken::AutoDecRef pyReal(PySequence_GetItem(%in, 0));
+        Shiboken::AutoDecRef pyImag(PySequence_GetItem(%in, 1));
+        double real = %CONVERTTOCPP[double](pyReal);
+        double imag  = %CONVERTTOCPP[double](pyImag);
+        %out = %OUTTYPE(real, imag);
+        </add-conversion>
 
-            </target-to-native>
+      </target-to-native>
 
-          </conversion-rule>
+    </conversion-rule>
 
-        </primitive-type>
+  </primitive-type>
 
 
 .. _container_conversions:
@@ -138,48 +138,48 @@ except that they make use of the type system variables
 |project| combines the conversion code for containers with the conversion
 defined (or automatically generated) for the containers.
 
-      .. code-block:: xml
-
-            <container-type name="std::map" type="map">
-              <include file-name="map" location="global"/>
-
-              <conversion-rule>
-
-                <native-to-target>
-                PyObject* %out = PyDict_New();
-                %INTYPE::const_iterator it = %in.begin();
-                for (; it != %in.end(); ++it) {
-                  %INTYPE_0 key = it->first;
-                  %INTYPE_1 value = it->second;
-                          PyDict_SetItem(%out,
-                                 %CONVERTTOPYTHON[%INTYPE_0](key),
-                         %CONVERTTOPYTHON[%INTYPE_1](value));
-                }
-                return %out;
-                </native-to-target>
-
-                <target-to-native>
-
-                  <add-conversion type="PyDict">
-                  PyObject* key;
-                  PyObject* value;
-                  Py_ssize_t pos = 0;
-                  while (PyDict_Next(%in, &amp;pos, &amp;key, &amp;value)) {
-                      %OUTTYPE_0 cppKey = %CONVERTTOCPP[%OUTTYPE_0](key);
-                      %OUTTYPE_1 cppValue = %CONVERTTOCPP[%OUTTYPE_1](value);
-                      %out.insert(%OUTTYPE::value_type(cppKey, cppValue));
-                  }
-                  </add-conversion>
-
-                </target-to-native>
-              </conversion-rule>
-            </container-type>
-
-.. note:: From version 6.3, we do not have to explicitly specify the
-          `<container-type/>` for C++ containers ``std::list``\, ``std::vector``\,
-          ``std::pair``\, ``std::map`` and ``std::unordered_map``\. They are
-          now built-in. However, they still have to be added for opaque
-          containers or when modifying the built-in behavior.
+.. code-block:: xml
+
+      <container-type name="std::map" type="map">
+        <include file-name="map" location="global"/>
+
+        <conversion-rule>
+
+          <native-to-target>
+          PyObject* %out = PyDict_New();
+          %INTYPE::const_iterator it = %in.begin();
+          for (; it != %in.end(); ++it) {
+            %INTYPE_0 key = it->first;
+            %INTYPE_1 value = it->second;
+                    PyDict_SetItem(%out,
+                           %CONVERTTOPYTHON[%INTYPE_0](key),
+                   %CONVERTTOPYTHON[%INTYPE_1](value));
+          }
+          return %out;
+          </native-to-target>
+
+          <target-to-native>
+
+            <add-conversion type="PyDict">
+            PyObject* key;
+            PyObject* value;
+            Py_ssize_t pos = 0;
+            while (PyDict_Next(%in, &amp;pos, &amp;key, &amp;value)) {
+                %OUTTYPE_0 cppKey = %CONVERTTOCPP[%OUTTYPE_0](key);
+                %OUTTYPE_1 cppValue = %CONVERTTOCPP[%OUTTYPE_1](value);
+                %out.insert(%OUTTYPE::value_type(cppKey, cppValue));
+            }
+            </add-conversion>
+
+          </target-to-native>
+        </conversion-rule>
+      </container-type>
+
+.. note:: The C++ containers ``std::list``\, ``std::vector``\,
+          ``std::pair``\, ``std::map``\, ``std::span`` and ``std::unordered_map`` are
+          built-in.
+          To specify :ref:`opaque-containers`, use the :ref:`opaque-container` element.
+          :ref:`container-type` can still be specified to modify the built-in behavior.
           For this case, a number of pre-defined conversion templates
           are provided (see :ref:`predefined_templates`).
 
@@ -192,14 +192,12 @@ Variables & Functions
 .. _in:
 
 **%in**
-
   Variable replaced by the C++ input variable.
 
 
 .. _out:
 
 **%out**
-
   Variable replaced by the C++ output variable. Needed to convey the
   result of a Python to C++ conversion.
 
@@ -207,7 +205,6 @@ Variables & Functions
 .. _intype:
 
 **%INTYPE**
-
   Used in Python to C++ conversions. It is replaced by the name of type for
   which the conversion is being defined. Don't use the type's name directly.
 
@@ -215,14 +212,12 @@ Variables & Functions
 .. _intype_n:
 
 **%INTYPE_#**
-
   Replaced by the name of the #th type used in a container.
 
 
 .. _outtype:
 
 **%OUTTYPE**
-
   Used in Python to C++ conversions. It is replaced by the name of type for
   which the conversion is being defined. Don't use the type's name directly.
 
@@ -230,71 +225,11 @@ Variables & Functions
 .. _outtype_n:
 
 **%OUTTYPE_#**
-
   Replaced by the name of the #th type used in a container.
 
 
 .. _checktype:
 
 **%CHECKTYPE[CPPTYPE]**
-
   Replaced by a |project| type checking function for a Python variable.
   The C++ type is indicated by ``CPPTYPE``.
-
-
-.. _oldconverters:
-
-Converting The Old Converters
-=============================
-
-If you use |project| for your bindings, and has defined some type conversions
-using the ``Shiboken::Converter`` template, then you must update your converters
-to the new scheme.
-
-Previously your conversion rules were declared in one line, like this:
-
-
-    .. code-block:: xml
-
-        <primitive-type name="Complex" target-lang-api-name="PyComplex">
-          <include file-name="complex.h" location="global"/>
-          <conversion-rule file="complex_conversions.h"/>
-        </primitive-type>
-
-
-And implemented in a separate C++ file, like this:
-
-
-    .. code-block:: c++
-
-        namespace Shiboken {
-        template<> struct Converter<Complex>
-        {
-            static inline bool checkType(PyObject* pyObj) {
-                return PyComplex_Check(pyObj);
-            }
-            static inline bool isConvertible(PyObject* pyObj) {
-                return PyComplex_Check(pyObj);
-            }
-            static inline PyObject* toPython(void* cppobj) {
-                return toPython(*reinterpret_cast<Complex*>(cppobj));
-            }
-            static inline PyObject* toPython(const Complex& cpx) {
-                return PyComplex_FromDoubles(cpx.real(), cpx.imag());
-            }
-            static inline Complex toCpp(PyObject* pyobj) {
-                double real =  PyComplex_RealAsDouble(pyobj);
-                double imag =  PyComplex_ImagAsDouble(pyobj);
-                return Complex(real, imag);
-            }
-        };
-        }
-
-
-In this case, the parts of the implementation that will be used in the new
-conversion-rule are the ones in the two last method
-``static inline PyObject* toPython(const Complex& cpx)`` and
-``static inline Complex toCpp(PyObject* pyobj)``. The ``isConvertible`` method
-is gone, and the ``checkType`` is now an attribute of the :ref:`add-conversion <add-conversion>`
-tag. Refer back to the first example in this page and you will be able to
-correlate the above template with the new scheme of conversion rule definition.
diff --git a/sources/shiboken6/doc/typesystem_documentation.rst b/sources/shiboken6/doc/typesystem_documentation.rst
index f03d8b70a..4e7d18b99 100644
--- a/sources/shiboken6/doc/typesystem_documentation.rst
+++ b/sources/shiboken6/doc/typesystem_documentation.rst
@@ -4,48 +4,59 @@ Manipulating Documentation
 inject-documentation
 ^^^^^^^^^^^^^^^^^^^^
 
-    The inject-documentation node inserts the documentation into the generated
-    documentation. This node is a child of the :ref:`object-type`,
-    :ref:`value-type` and :ref:`modify-function` nodes.
+The inject-documentation node inserts the documentation into the generated
+documentation. This node is a child of the :ref:`object-type`,
+:ref:`value-type` and :ref:`modify-function` nodes.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <value-type>
-             <inject-documentation mode="append | prepend | replace" format="native | target" >
-                 // the documentation
-             </inject-code>
-         </value-type>
+     <value-type>
+         <inject-documentation mode="append | prepend | replace" format="native | target"
+                               file="[file]" snippet="[label]">
+             // the documentation
+         </inject-code>
+     </value-type>
 
-    The **mode** attribute default value is *replace*.
+The **mode** attribute default value is *replace*.
 
-    The **format** attribute specifies when the documentation injection will
-    occur and it accepts the following values:
+The **format** attribute specifies when the documentation injection will
+occur and it accepts the following values:
 
-        * native: Before XML<->Backend transformation occur, so the injected code *must* be a valid XML.
-        * target: After XML<->Backend transformation occur, so the injected code *must* be a valid backend format.
+* native: Before XML<->Backend transformation occur, so the injected code *must* be a valid XML.
+* target: After XML<->Backend transformation occur, so the injected code *must* be a valid backend format.
 
-    At the moment the only supported backend is Sphinx.
+The optional ``file`` attribute specifies the file name
+(see :ref:`external-snippets`).
+
+The optional ``snippet`` attribute specifies the snippet label
+(see :ref:`external-snippets`).
+
+At the moment the only supported backend is Sphinx.
+
+If the injected documentation contains a Sphinx function directive, no
+directive will be auto-generated. This can be used to add parameter
+documentation to added functions.
 
 modify-documentation
 ^^^^^^^^^^^^^^^^^^^^
 
-    The modify-documentation node allows you to change the auto-generated
-    documentation. . This node is a child of the :ref:`object-type`,
-    :ref:`value-type` and :ref:`modify-function` nodes.
-    API Extractor transforms XML's from `qdoc`_ (the Qt documentation
-    tool) into .rst files to be processed later using `Sphinx`_. You can modify
-    the XML before the transformation takes place.
+The modify-documentation node allows you to change the auto-generated
+documentation. . This node is a child of the :ref:`object-type`,
+:ref:`value-type` and :ref:`modify-function` nodes.
+API Extractor transforms XML's from `qdoc`_ (the Qt documentation
+tool) into .rst files to be processed later using `Sphinx`_. You can modify
+the XML before the transformation takes place.
 
 .. _`qdoc`: https://doc.qt.io/qt-6/qdoc-index.html
 
 .. _`Sphinx`: https://www.sphinx-doc.org/en/master
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <modify-documentation xpath="...">
-            <!-- new documentation -->
-        </modify-documentation>
+    <modify-documentation xpath="...">
+        <!-- new documentation -->
+    </modify-documentation>
 
-    The **xpath** attribute is the `XPath`_ to the node that you want to modify.
+The **xpath** attribute is the `XPath`_ to the node that you want to modify.
 
 .. _`XPath`: https://www.w3.org/TR/1999/REC-xpath-19991116/
diff --git a/sources/shiboken6/doc/typesystem_manipulating_objects.rst b/sources/shiboken6/doc/typesystem_manipulating_objects.rst
index c8d35cf9c..e024cdf00 100644
--- a/sources/shiboken6/doc/typesystem_manipulating_objects.rst
+++ b/sources/shiboken6/doc/typesystem_manipulating_objects.rst
@@ -8,75 +8,75 @@ Manipulating Object and Value Types
 inject-code
 ^^^^^^^^^^^
 
-    The ``inject-code`` node inserts the given code into the generated code for the
-    given type or function, and it is a child of the :ref:`object-type`, :ref:`value-type`,
-    :ref:`modify-function` and :ref:`add-function` nodes.
-    It may contain :ref:`insert-template` child nodes.
+The ``inject-code`` node inserts the given code into the generated code for the
+given type or function, and it is a child of the :ref:`object-type`, :ref:`value-type`,
+:ref:`modify-function` and :ref:`add-function` nodes.
+It may contain :ref:`insert-template` child nodes.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <inject-code class="native | target"
-                     position="beginning | end" since="..."
-                     file="[file]"
-                     snippet="[label]"/>
+    <inject-code class="native | target"
+                 position="beginning | end" since="..."
+                 file="[file]"
+                 snippet="[label]"/>
 
 
-    The ``class`` attribute specifies which module of the generated code that
-    will be affected by the code injection
-    (see :ref:`codegenerationterminology`). The ``class`` attribute accepts the
-    following values:
+The ``class`` attribute specifies which module of the generated code that
+will be affected by the code injection
+(see :ref:`codegenerationterminology`). The ``class`` attribute accepts the
+following values:
 
-        * ``native``: The c++ code
-        * ``target``: The binding code
+* ``native``: The c++ code
+* ``target``: The binding code
 
-    If the ``position`` attribute is set to *beginning* (the default), the code
-    is inserted at the beginning of the function. If it is set to *end*, the code
-    is inserted at the end of the function.
+If the ``position`` attribute is set to *beginning* (the default), the code
+is inserted at the beginning of the function. If it is set to *end*, the code
+is inserted at the end of the function.
 
-    For a detailed description of how to above attributes interact,
-    see :ref:`codeinjectionsemantics`.
+For a detailed description of how to above attributes interact,
+see :ref:`codeinjectionsemantics`.
 
-    The optional ``file`` attribute specifies the file name
-    (see :ref:`external-snippets`).
+The optional ``file`` attribute specifies the file name
+(see :ref:`external-snippets`).
 
-    The optional ``snippet`` attribute specifies the snippet label
-    (see :ref:`external-snippets`).
+The optional ``snippet`` attribute specifies the snippet label
+(see :ref:`external-snippets`).
 
-    There are a number of placeholders which are replaced when injecting
-    code (see :ref:`typesystemvariables`).
+There are a number of placeholders which are replaced when injecting
+code (see :ref:`typesystemvariables`).
 
-    There are severals ways to specify the code:
+There are severals ways to specify the code:
 
 Embedding Code into XML
 =======================
 
-    The code can be embedded into XML (be careful to use the correct XML entities
-    for characters like '<', '>', '&'):
+The code can be embedded into XML (be careful to use the correct XML entities
+for characters like '<', '>', '&'):
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <value-type>
-             <inject-code class="native | target"
-                 position="beginning | end" since="...">
-                 // the code
-             </inject-code>
-         </value-type>
+     <value-type>
+         <inject-code class="native | target"
+             position="beginning | end" since="...">
+             // the code
+         </inject-code>
+     </value-type>
 
 
 Using a Template Specified in XML
 =================================
 
-    It is possible to create code templates for reuse in XML
-    (see :ref:`using-code-templates`). This allows for replacing of custom
-    placeholders.
+It is possible to create code templates for reuse in XML
+(see :ref:`using-code-templates`). This allows for replacing of custom
+placeholders.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <value-type>
-             <inject-code class="native | target" class="native | target">
-                 <insert-template name="template_name"/>
-             </inject-code>
-         </value-type>
+     <value-type>
+         <inject-code class="native | target" class="native | target">
+             <insert-template name="template_name"/>
+         </inject-code>
+     </value-type>
 
 
 .. _external-snippets:
@@ -84,272 +84,291 @@ Using a Template Specified in XML
 Using Snippets From External Files
 ==================================
 
-    Code snippets can also be retrieved from external files found in the
-    typesystem search path (see :ref:`typesystem-paths`).
+Code or documentation snippets can also be retrieved from external
+files found in the typesystem search path (see :ref:`typesystem-paths`).
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <value-type>
-             <inject-code class="native | target"
-                 position="beginning | end" since="..."
-                 file="external_source.cpp"
-                 snippet="label"/>
-         </value-type>
+     <value-type>
+         <inject-code class="native | target"
+             position="beginning | end" since="..."
+             file="external_source.cpp"
+             snippet="label"/>
+     </value-type>
 
 
-    In the external file ``external_source.cpp``, the code between annotations
-    of the form:
+In the external file ``external_source.cpp``, the code between annotations
+of the form:
 
-    .. code-block:: c++
+.. code-block:: c++
 
-        // @snippet label
-        ...
-        // @snippet label
+    // @snippet label
+    ...
+    // @snippet label
 
 
-    will be extracted.
+will be extracted.
 
 .. _modify-field:
 
 modify-field
 ^^^^^^^^^^^^
 
-    The ``modify-field`` node allows you to alter the access privileges for a given
-    C++ field when mapping it onto the target language, and it is a child of an
-    :ref:`object-type` or a :ref:`value-type` node.
+The ``modify-field`` node allows you to alter the access privileges for a given
+C++ field when mapping it onto the target language, and it is a child of an
+:ref:`object-type` or a :ref:`value-type` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <object-type>
-             <modify-field name="..."
-                 write="true | false"
-                 read="true | false"
-                 remove="true | false"
-                 opaque-container = "yes | no"
-                 snake-case="yes | no | both" />
-         </object-type>
+     <object-type>
+         <modify-field name="..."
+             write="true | false"
+             read="true | false"
+             remove="true | false"
+             opaque-container = "yes | no"
+             snake-case="yes | no | both" />
+     </object-type>
 
-    The ``name`` attribute is the name of the field, the *optional* ``write``
-    and ``read`` attributes specify the field's access privileges in the target
-    language API (both are set to true by default).
+The ``name`` attribute is the name of the field, the *optional* ``write``
+and ``read`` attributes specify the field's access privileges in the target
+language API (both are set to true by default).
 
-    The ``remove`` attribute is an *optional* boolean attribute, which can
-    mark the field to be discarded on generation.
+The ``remove`` attribute is an *optional* boolean attribute, which can
+mark the field to be discarded on generation.
 
-    The  *optional* ``rename`` attribute can be used to change the name of the
-    given field in the generated target language API.
+The *optional* ``rename`` attribute can be used to change the name of the
+given field in the generated target language API.
 
-    The *optional* ``opaque-container`` attribute specifies whether
-    an opaque container should be returned on read access
-    (see :ref:`opaque-containers`).
+The *optional* ``opaque-container`` attribute specifies whether
+an opaque container should be returned on read access
+(see :ref:`opaque-containers`).
 
-    The *optional* **snake-case** attribute allows for overriding the value
-    specified on the class entry or **typesystem** element.
+The *optional* **snake-case** attribute allows for overriding the value
+specified on the class entry or **typesystem** element.
 
 .. _modify-function:
 
 modify-function
 ^^^^^^^^^^^^^^^
 
-    The ``modify-function`` node allows you to modify a given C++ function when
-    mapping it onto the target language, and it is a child of a :ref:`function`,
-    :ref:`namespace`, :ref:`object-type` or a :ref:`value-type` node.
-    Use the :ref:`modify-argument` node to specify which argument the
-    modification affects.
-
-    .. code-block:: xml
-
-         <object-type>
-             <modify-function signature="..."
-                              since="..."
-                              remove="true | false"
-                              access="public | private | protected"
-                              allow-thread="true | auto | false"
-                              exception-handling="off | auto-off | auto-on | on"
-                              final="true | false"
-                              overload-number="number"
-                              rename="..."
-                              snake-case="yes | no | both" />
-         </object-type>
-
-    The ``signature`` attribute is a normalized C++ signature, excluding return
-    values but including potential const declarations. It is not required
-    when ``modify-function`` appears as a child of a :ref:`function` node to
-    modify a global function.
-
-    The ``since`` attribute specify the API version when this function was modified.
-
-    The ``allow-thread`` attribute specifies whether a function should be wrapped
-    into ``Py_BEGIN_ALLOW_THREADS`` and ``Py_END_ALLOW_THREADS``, that is,
-    temporarily release the GIL (global interpreter lock). Doing so is required
-    for any thread-related  function (wait operations), functions that might call
-    a virtual function (potentially reimplemented in Python), and recommended for
-    lengthy I/O operations or similar. It has performance costs, though.
-    The value ``auto`` means that it will be turned off for functions for which
-    it is deemed to be safe, for example, simple getters.
-    The attribute defaults to ``false``.
-
-    The ``exception-handling`` attribute specifies whether to generate exception
-    handling code (nest the function call into try / catch statements). It accepts
-    the following values:
-
-           * no, false: Do not generate exception handling code
-           * auto-off: Generate exception handling code for functions
-             declaring a non-empty ``throw`` list
-           * auto-on: Generate exception handling code unless function
-             declares ``noexcept``
-           * yes, true: Always generate exception handling code
-
-    The optional ``overload-number`` attribute specifies the position of the
-    overload when checking arguments. Typically, when a number of overloads
-    exists, as for in example in Qt:
-
-    .. code-block:: c++
-
-        void QPainter::drawLine(QPointF, QPointF);
-        void QPainter::drawLine(QPoint, QPoint);
-
-    they will be reordered such that the check for matching arguments for the
-    one taking a ``QPoint`` is done first. This is to avoid a potentially
-    costly implicit conversion from ``QPoint`` to ``QPointF`` when using the
-    2nd overload. There are cases though in which this is not desired;
-    most prominently when a class inherits from a container and overloads exist
-    for both types as is the case for the ``QPolygon`` class:
-
-    .. code-block:: c++
-
-        class QPolygon : public QList<QPoint> {};
-
-        void QPainter::drawPolygon(QPolygon);
-        void QPainter::drawPolygon(QList<QPoint>);
-
-    By default, the overload taking a ``QList`` will be checked first, trying
-    to avoid constructing a ``QPolygon`` from ``QList``. The type check for a
-    list of points will succeed for a parameter of type ``QPolygon``, too,
-    since it inherits ``QList``. This presents a problem since the sequence
-    type check is costly due to it checking that each container element is a
-    ``QPoint``. It is thus preferable to check for the ``QPolygon`` overload
-    first. This is achieved by specifying numbers as follows:
-
-    .. code-block:: xml
-
-        <object-type name="QPainter">
-            <modify-function signature="drawPolygon(QPolygon)" overload-number="0"/>
-            <modify-function signature="drawPolygon(QList&lt;QPoint&gt;)" overload-number="1"/>
-        </object-type>
-
-    Numbers should be given for all overloads; otherwise, the order will be in
-    declaration order.
-
-    The optional ``final`` attribute can be specified for virtual functions
-    and disables generating the code for overriding the function in Python
-    (native call). This is useful when the result type is not constructible.
-
-    The ``remove`` attribute is an *optional* boolean attribute, which can
-    mark the function to be discarded on generation.
-
-    The  *optional* ``rename`` attribute can be used to change the name of the
-    given function in the generated target language API.
-
-    The  *optional* ``access`` attribute changes the access privileges of the
-    given function in the generated target language API.
-
-    The *optional* **snake-case** attribute allows for overriding the value
-    specified on the class entry or **typesystem** element.
+The ``modify-function`` node allows you to modify a given C++ function when
+mapping it onto the target language, and it is a child of a :ref:`function`,
+:ref:`namespace`, :ref:`object-type` or a :ref:`value-type` node.
+Use the :ref:`modify-argument` node to specify which argument the
+modification affects.
+
+.. code-block:: xml
+
+     <object-type>
+         <modify-function signature="..."
+                          since="..."
+                          remove="true | false"
+                          access="public | private | protected"
+                          allow-thread="true | auto | false"
+                          exception-handling="no | auto-off | auto-on | yes"
+                          final="true | false"
+                          overload-number="number"
+                          rename="..."
+                          snake-case="yes | no | both"
+                          deprecated = "true | false" />
+     </object-type>
+
+The ``signature`` attribute is a normalized C++ signature, excluding return
+values but including potential const declarations. It is not required
+when ``modify-function`` appears as a child of a :ref:`function` node to
+modify a global function.
+
+The ``since`` attribute specify the API version when this function was modified.
+
+The ``allow-thread`` attribute specifies whether a function should be wrapped
+into ``Py_BEGIN_ALLOW_THREADS`` and ``Py_END_ALLOW_THREADS``, that is,
+temporarily release the GIL (global interpreter lock). Doing so is required
+for any thread-related function (wait operations), functions that might call
+a virtual function (potentially reimplemented in Python), and recommended for
+lengthy I/O operations or similar. It has performance costs, though.
+The value ``auto`` means that it will be turned off for functions for which
+it is deemed to be safe, for example, simple getters.
+The attribute defaults to ``false``.
+
+The ``exception-handling`` attribute specifies whether to generate exception
+handling code (nest the function call into try / catch statements). It accepts
+the following values:
+
+* no, false: Do not generate exception handling code
+* auto-off: Generate exception handling code for functions
+  declaring a non-empty ``throw`` list
+* auto-on: Generate exception handling code unless function
+  declares ``noexcept``
+* yes, true: Always generate exception handling code
+
+The optional ``overload-number`` attribute specifies the position of the
+overload when checking arguments. Typically, when a number of overloads
+exists, as for in example in Qt:
+
+.. code-block:: c++
+
+    void QPainter::drawLine(QPointF, QPointF);
+    void QPainter::drawLine(QPoint, QPoint);
+
+they will be reordered such that the check for matching arguments for the
+one taking a ``QPoint`` is done first. This is to avoid a potentially
+costly implicit conversion from ``QPoint`` to ``QPointF`` when using the
+2nd overload. There are cases though in which this is not desired;
+most prominently when a class inherits from a container and overloads exist
+for both types as is the case for the ``QPolygon`` class:
+
+.. code-block:: c++
+
+    class QPolygon : public QList<QPoint> {};
+
+    void QPainter::drawPolygon(QPolygon);
+    void QPainter::drawPolygon(QList<QPoint>);
+
+By default, the overload taking a ``QList`` will be checked first, trying
+to avoid constructing a ``QPolygon`` from ``QList``. The type check for a
+list of points will succeed for a parameter of type ``QPolygon``, too,
+since it inherits ``QList``. This presents a problem since the sequence
+type check is costly due to it checking that each container element is a
+``QPoint``. It is thus preferable to check for the ``QPolygon`` overload
+first. This is achieved by specifying numbers as follows:
+
+.. code-block:: xml
+
+    <object-type name="QPainter">
+        <modify-function signature="drawPolygon(QPolygon)" overload-number="0"/>
+        <modify-function signature="drawPolygon(QList&lt;QPoint&gt;)" overload-number="1"/>
+    </object-type>
+
+Numbers should be given for all overloads; otherwise, the order will be in
+declaration order.
+
+The optional ``final`` attribute can be specified for virtual functions
+and disables generating the code for overriding the function in Python
+(native call). This is useful when the result type is not constructible.
+
+The ``remove`` attribute is an *optional* boolean attribute, which can
+mark the function to be discarded on generation.
+
+The *optional* ``rename`` attribute can be used to change the name of the
+given function in the generated target language API.
+
+The *optional* ``access`` attribute changes the access privileges of the
+given function in the generated target language API.
+
+The *optional* **snake-case** attribute allows for overriding the value
+specified on the class entry or **typesystem** element.
+
+The *optional* **deprecated** attribute allows for overriding deprecation
+as detected by the C++ attribute. It works in both ways.
 
 .. _add-function:
 
 add-function
 ^^^^^^^^^^^^
 
-    The ``add-function`` node allows you to add a given function onto the target
-    language, and it is a child of an :ref:`object-type` or :ref:`value-type` nodes if the
-    function is supposed to be a method, or :ref:`namespace` and :ref:`typesystem` if
-    the function is supposed to be a function inside a namespace or a global function.
-    It may contain :ref:`modify-argument` nodes.
+The ``add-function`` node allows you to add a given function onto the target
+language, and it is a child of an :ref:`object-type` or :ref:`value-type` nodes if the
+function is supposed to be a method, or :ref:`namespace` and :ref:`typesystem` if
+the function is supposed to be a function inside a namespace or a global function.
+It may contain :ref:`modify-argument` nodes.
 
-    Typically when adding a function some code must be injected to provide the function
-    logic. This can be done using the :ref:`inject-code` node.
+Typically when adding a function some code must be injected to provide the function
+logic. This can be done using the :ref:`inject-code` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <object-type>
-             <add-function signature="..." return-type="..."
-                           access="public | protected"
-                           static="yes | no" classmethod="yes | no"
-                           since="..."/>
-         </object-type>
+     <object-type>
+         <add-function signature="..." return-type="..."
+                       access="public | protected"
+                       overload-number="number"
+                       static="yes | no" classmethod="yes | no"
+                       python-override ="yes | no"
+                       since="..."/>
+     </object-type>
 
-    The ``return-type`` attribute defaults to *void*, the ``access`` to *public* and the ``static`` one to *no*.
+The ``return-type`` attribute defaults to *void*, the ``access`` to *public* and the ``static`` one to *no*.
 
-    The ``since`` attribute specifies the API version when this function was added.
+The ``since`` attribute specifies the API version when this function was added.
 
-    The ``classmethod`` attribute specifies whether the function should be a Python class method.
-    It sets the METH_CLASS flag which means that ``PyTypeObject`` instead of an instance
-    ``PyObject`` is passed as self, which needs to be handled in injected code.
+The ``classmethod`` attribute specifies whether the function should be a Python class method.
+It sets the METH_CLASS flag which means that ``PyTypeObject`` instead of an instance
+``PyObject`` is passed as self, which needs to be handled in injected code.
 
-    Note that the label "static" in Qt's class documentation almost always means that a Python
-    ``classmethod`` should be generated, because an object's class is always accessible from the
-    static C++ code, while Python needs the explicit "self" parameter that ``classmethod``
-    provides.
+For the *optional* attribute ``overload-number``, see :ref:`modify-function`.
 
-    In order to create keyword argument supporting function parameters, enclose the specific
-    function parameter with a *@* in the `signature` field.
+Note that the label "static" in Qt's class documentation almost always means that a Python
+``classmethod`` should be generated, because an object's class is always accessible from the
+static C++ code, while Python needs the explicit "self" parameter that ``classmethod``
+provides.
 
-    .. code-block:: xml
+In order to create keyword argument supporting function parameters, enclose the specific
+function parameter with a *@* in the `signature` field.
 
-        <add-function signature="foo(int @parameter1@,float @parameter2@)">
-            ...
-        </add-function>
+.. code-block:: xml
 
-    With keyword arguments, ``add-function`` makes it easy to specify a default argument
-    within the `signature` field
+    <add-function signature="foo(int @parameter1@,float @parameter2@)">
+        ...
+    </add-function>
 
-    .. code-block:: xml
+With keyword arguments, ``add-function`` makes it easy to specify a default argument
+within the `signature` field
 
-        <add-function signature="foo(int @parameter1@=1,float @parameter2@=2)">
-            ...
-        </add-function>
+.. code-block:: xml
+
+    <add-function signature="foo(int @parameter1@=1,float @parameter2@=2)">
+        ...
+    </add-function>
+
+See :ref:`sequence-protocol` for adding the respective functions.
 
-    See :ref:`sequence-protocol` for adding the respective functions.
+The *optional* attribute ``python-override`` indicates a special type
+of added function, a python-override that will be generated into
+the native wrapper (see :ref:`modifying-virtual-functions`).
 
 .. _declare-function:
 
 declare-function
 ^^^^^^^^^^^^^^^^
 
-    The ``declare-function`` node allows you to declare a function present in
-    the type and it is a child of an :ref:`object-type` or :ref:`value-type` nodes
-    if the function is supposed to be a method, or :ref:`namespace` and
-    :ref:`typesystem` if the function is supposed to be a function inside a
-    namespace or a global function. It may contain :ref:`modify-argument` nodes.
+The ``declare-function`` node allows you to declare a function present in
+the type and it is a child of an :ref:`object-type` or :ref:`value-type` nodes
+if the function is supposed to be a method, or :ref:`namespace` and
+:ref:`typesystem` if the function is supposed to be a function inside a
+namespace or a global function. It may contain :ref:`modify-argument` nodes.
 
-    .. code-block:: xml
+.. code-block:: xml
+
+     <container-type>
+         <declare-function signature="..." return-type="..." since="..."
+                           allow-thread="true | auto | false"
+                           exception-handling="off | auto-off | auto-on | on"
+                           overload-number="number"
+                           snake-case="yes | no | both"/>
+     </container-type>
 
-         <container-type>
-             <declare-function signature="..." return-type="..." since="..."/>
-         </container-type>
+The ``return-type`` attribute defaults to *void*.
 
-    The ``return-type`` attribute defaults to *void*.
+The ``since`` attribute specifies the API version when this function was
+added.
 
-    The ``since`` attribute specifies the API version when this function was
-    added.
+For the *optional* attributes ``allow-thread``, ``exception-handling``,
+``overload-number`` and ``snake-case``, see :ref:`modify-function`.
 
-    This is useful to make functions known to shiboken which its code parser
-    does not detect. For example, in Qt 6, the ``append()`` function of the
-    ``QList<T>`` container takes an argument of ``parameter_type`` which is
-    specialized to ``T`` for simple types and ``const T &`` for complex types
-    by some template expression which the code parser cannot resolve.
-    In that case, the function can be declared with a simple signature:
+This is useful to make functions known to shiboken which its code parser
+does not detect. For example, in Qt 6, the ``append()`` function of the
+``QList<T>`` container takes an argument of ``parameter_type`` which is
+specialized to ``T`` for simple types and ``const T &`` for complex types
+by some template expression which the code parser cannot resolve.
+In that case, the function can be declared with a simple signature:
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <container-type name="QList">
-             <declare-function signature="append(T)"/>
-         </container-type>
+     <container-type name="QList">
+         <declare-function signature="append(T)"/>
+     </container-type>
 
-    This tells shiboken a public function of that signature exists and
-    bindings will be created in specializations of ``QList``.
+This tells shiboken a public function of that signature exists and
+bindings will be created in specializations of ``QList``.
 
 
 .. _add-pymethoddef:
@@ -388,75 +407,150 @@ of signatures of the function.
 property
 ^^^^^^^^
 
-    The ``property`` element allows you to specify properties consisting of
-    a type and getter and setter functions.
+The ``property`` element allows you to specify properties consisting of
+a type and getter and setter functions.
 
-    It may appear as a child of a complex type such as :ref:`object-type` or
-    :ref:`value-type`.
+It may appear as a child of a complex type such as :ref:`object-type` or
+:ref:`value-type`.
 
-    If the PySide6 extension is not present, code will be generated using the
-    ``PyGetSetDef`` struct, similar to what is generated for fields.
+If the PySide6 extension is not present, code will be generated using the
+``PyGetSetDef`` struct, similar to what is generated for fields.
 
-    If the PySide6 extension is present, those properties complement the
-    properties obtained from the ``Q_PROPERTY`` macro in Qt-based code.
-    The properties will be handled in ``libpyside`` unless code generation
-    is forced.
+If the PySide6 extension is present, those properties complement the
+properties obtained from the ``Q_PROPERTY`` macro in Qt-based code.
+The properties will be handled in ``libpyside`` unless code generation
+is forced.
 
-    .. code-block:: xml
+.. code-block:: xml
+
+    <property name="..." type="..." get="..." set="..."
+              generate-getsetdef="yes | no" since="..."/>
+
+The ``name`` attribute specifies the name of the property, the ``type``
+attribute specifies the C++ type and the ``get`` attribute specifies the
+name of the accessor function.
+
+The optional ``set`` attribute specifies name of the setter function.
+
+The optional ``generate-getsetdef`` attribute specifies whether to generate
+code for if the PySide6 extension is present (indicating this property is not
+handled by libpyside). It defaults to *no*.
+
+The optional ``since`` attribute specifies the API version when this
+property appears.
+
+For a typical C++ class, like:
+
+.. code-block:: c++
+
+    class Test {
+    public:
+        int getValue() const;
+        void setValue();
+    };
+
+``value`` can then be specified to be a property:
+
+.. code-block:: xml
+
+    <value-type name="Test">
+        <property name="value" type="int" get="getValue" set="setValue"/>
+
+With that, a more pythonic style can be used:
+
+.. code-block:: python
 
-        <property name="..." type="..." get="..." set="..."
-                  generate-getsetdef="yes | no" since="..."/>
+    test = Test()
+    test.value = 42
 
-    The ``name`` attribute specifies the name of the property, the ``type``
-    attribute specifies the C++ type and the ``get`` attribute specifies the
-    name of the accessor function.
+For Qt classes (with the PySide6 extension present), additional setters
+and getters that do not appear as ``Q_PROPERTY``, can be specified to
+be properties:
 
-    The optional ``set`` attribute specifies name of the setter function.
+.. code-block:: xml
+
+    <object-type name="QMainWindow">
+        <property name="centralWidget" type="QWidget *"
+                  get="centralWidget" set="setCentralWidget"/>
+
+in addition to the normal properties of ``QMainWindow`` defined for
+Qt Designer usage.
+
+.. note:: In the *Qt* coding style, the property name typically conflicts
+    with the getter name. It is recommended to exclude the getter from the
+    wrapper generation using the ``remove`` function modification.
 
-    The optional ``generate-getsetdef`` attribute specifies whether to generate
-    code for if the PySide6 extension is present (indicating this property is not
-    handled by libpyside). It defaults to *no*.
+.. _configuration-element:
 
-    The optional ``since`` attribute specifies the API version when this
-    property appears.
+configuration
+^^^^^^^^^^^^^
+
+The ``configuration`` element allows you to generate a preprocessor
+condition excluding a type depending on an expression into the module
+header. This is specifically tailored to the
+`Qt Feature system <https://doc.qt.io/qt-6/configure-options.html>`_ ,
+but may also be used for similar systems.
+
+It may appear as a child of a complex type such as :ref:`object-type` or
+:ref:`value-type`.
+
+.. code-block:: xml
 
-    For a typical C++ class, like:
+    <configuration condition="..."/>
 
-    .. code-block:: c++
+The ``condition`` attribute specifies the preprocessor condition.
 
-        class Test {
-        public:
-            int getValue() const;
-            void setValue();
-        };
+This is an alternative way of omitting classes depending on some
+configuration (see also option :ref:`drop-type-entries`) intended
+for building several configurations from one generated source tree,
+but still requires listing the correct source files in the
+``CMakeLists.txt`` file.
 
-    ``value`` can then be specified to be a property:
+.. _modifying-virtual-functions:
 
-    .. code-block:: xml
+Modifying virtual functions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-        <value-type name="Test">
-            <property name="value" type="int" get="getValue" set="setValue"/>
+Some C++ virtual functions are unsuitable for Python bindings:
 
-    With that, a more pythonic style can be used:
+.. code-block:: c
 
-    .. code-block:: python
+    virtual void getInt(int *result) const;
 
-        test = Test()
-        test.value = 42
+In that case, you would modify it to return the integer instead (or a tuple
+in case of several out-parameters):
 
-    For Qt classes (with the PySide6 extension present), additional setters
-    and getters that do not appear as ``Q_PROPERTY``, can be specified to
-    be properties:
+.. code-block:: c
 
-    .. code-block:: xml
+    virtual int getInt() const;
 
-        <object-type name="QMainWindow">
-            <property name="centralWidget" type="QWidget *"
-                      get="centralWidget" set="setCentralWidget"/>
+For the binding itself, use the common argument modifications (removing
+arguments, modifying return types with injected code snippets) to modify the
+signature.
 
-    in addition to the normal properties of ``QMainWindow`` defined for
-    Qt Designer usage.
+To make it possible to reimplement the function in Python with the modified
+signature, add a ``python-override`` function with that signature, using an
+arbitrary name for disambiguation:
+
+.. code-block:: xml
+
+       <add-function signature="getIntPyOverride()"
+                     return-type="int" python-override="true"/>
+
+This causes a static function performing the call into Python for the override
+to be generated into the native wrapper.
+
+In the existing virtual function, inject a code snippet at the ``shell`` /
+``override`` position which calls the newly added function. The first 2
+arguments are the `Global interpreter lock handle` (``Shiboken::GilState``) and
+the Python method determined by the override check (``PyObject *``). The
+snippet then converts the arguments and return values and returns after that:
+
+.. code-block:: xml
 
-    .. note:: In the *Qt* coding style, the property name typically conflicts
-        with the getter name. It is recommended to exclude the getter from the
-        wrapper generation using the ``remove`` function modification.
+       <modify-function signature="getInt(int*)const">
+           <inject-code class="shell" position="override">
+           *result = getIntPyOverride(gil, pyOverride.object());
+           return;
+           </inject-code>
+       </modify-function>
diff --git a/sources/shiboken6/doc/typesystem_modify_function.rst b/sources/shiboken6/doc/typesystem_modify_function.rst
index 1e882f9c7..54ac6412f 100644
--- a/sources/shiboken6/doc/typesystem_modify_function.rst
+++ b/sources/shiboken6/doc/typesystem_modify_function.rst
@@ -8,37 +8,37 @@ Modifying Functions
 modify-argument
 ^^^^^^^^^^^^^^^
 
-    Function modifications consist of a list of ``modify-argument`` nodes
-    contained in :ref:`modify-function`, :ref:`add-function` or
-    :ref:`declare-function` nodes. Use the :ref:`remove-argument`,
-    :ref:`replace-default-expression`, :ref:`remove-default-expression`,
-    :ref:`replace-type`, :ref:`reference-count` and :ref:`define-ownership`
-    nodes to specify the details of the modification.
-
-    .. code-block:: xml
-
-         <modify-function>
-             <modify-argument index="return | this | 1 ..." rename="..."
-              invalidate-after-use = "true | false" pyi-type="...">
-                 // modifications
-             </modify-argument>
-         </modify-function>
-
-    Set the ``index`` attribute to "1" for the first argument, "2" for the second
-    one and so on. Alternatively, set it to "return" or "this" if you want to
-    modify the function's return value or the object the function is called upon,
-    respectively.
-
-    The optional ``rename`` attribute is used to rename a argument and use this
-    new name in the generated code. This attribute can be used to enable the usage
-    of ``keyword arguments``.
-
-    The optional ``pyi-type`` attribute specifies the type to appear in the
-    signature strings and  ``.pyi`` files. The type string is determined by
-    checking this attribute value, the :ref:`replace-type` modification and
-    the C++ type. The attribute can be used for example to enclose
-    a pointer return value within ``Optional[]`` to indicate that ``None``
-    can occur.
-
-    For the optional ``invalidate-after-use`` attribute,
-    see :ref:`invalidationafteruse` .
+Function modifications consist of a list of ``modify-argument`` nodes
+contained in :ref:`modify-function`, :ref:`add-function` or
+:ref:`declare-function` nodes. Use the :ref:`remove-argument`,
+:ref:`replace-default-expression`, :ref:`remove-default-expression`,
+:ref:`replace-type`, :ref:`reference-count` and :ref:`define-ownership`
+nodes to specify the details of the modification.
+
+.. code-block:: xml
+
+     <modify-function>
+         <modify-argument index="return | this | 1 ..." rename="..."
+          invalidate-after-use = "true | false" pyi-type="...">
+             // modifications
+         </modify-argument>
+     </modify-function>
+
+Set the ``index`` attribute to "1" for the first argument, "2" for the second
+one and so on. Alternatively, set it to "return" or "this" if you want to
+modify the function's return value or the object the function is called upon,
+respectively.
+
+The optional ``rename`` attribute is used to rename a argument and use this
+new name in the generated code. This attribute can be used to enable the usage
+of ``keyword arguments``.
+
+The optional ``pyi-type`` attribute specifies the type to appear in the
+signature strings and  ``.pyi`` files. The type string is determined by
+checking this attribute value, the :ref:`replace-type` modification and
+the C++ type. The attribute can be used for example to enclose
+a pointer return value within ``Optional[]`` to indicate that ``None``
+can occur.
+
+For the optional ``invalidate-after-use`` attribute,
+see :ref:`invalidationafteruse` .
diff --git a/sources/shiboken6/doc/typesystem_ownership.rst b/sources/shiboken6/doc/typesystem_ownership.rst
index f412fc609..a5440e49e 100644
--- a/sources/shiboken6/doc/typesystem_ownership.rst
+++ b/sources/shiboken6/doc/typesystem_ownership.rst
@@ -58,39 +58,39 @@ The following situations can invalidate an object:
 C++ taking ownership
 --------------------
 
-    When an object is passed to a function or method that takes ownership of it, the wrapper
-    is invalidated as we can't be sure of when the object is destroyed, unless it has a
-    :ref:`virtual destructor <ownership-virt-method>` or the transfer is due to the special case
-    of :ref:`parent ownership <ownership-parent>`.
+When an object is passed to a function or method that takes ownership of it, the wrapper
+is invalidated as we can't be sure of when the object is destroyed, unless it has a
+:ref:`virtual destructor <ownership-virt-method>` or the transfer is due to the special case
+of :ref:`parent ownership <ownership-parent>`.
 
-    Besides being passed as argument, the called object can have its ownership changed, like
-    the `setParent` method in Qt's `QObject`.
+Besides being passed as argument, the called object can have its ownership changed, like
+the `setParent` method in Qt's `QObject`.
 
 Invalidate after use
 --------------------
 
-    Objects marked with *invalidate-after-use* in the type system description always are
-    virtual method arguments provided by a C++ originated call. They should be
-    invalidated right after the Python function returns (see :ref:`invalidationafteruse`).
+Objects marked with *invalidate-after-use* in the type system description always are
+virtual method arguments provided by a C++ originated call. They should be
+invalidated right after the Python function returns (see :ref:`invalidationafteruse`).
 
 .. _ownership-virt-method:
 
 Objects with virtual methods
 ----------------------------
 
-    A little bit of implementation details (see also :ref:`codegenerationterminology`):
-    virtual methods are supported by creating a C++ class, the **shell**, that inherits
-    from the class with virtual methods, the native one, and override those methods to check if
-    any derived class in Python also override it.
+A little bit of implementation details (see also :ref:`codegenerationterminology`):
+virtual methods are supported by creating a C++ class, the **shell**, that inherits
+from the class with virtual methods, the native one, and override those methods to check if
+any derived class in Python also override it.
 
-    If the class has a virtual destructor (and C++ classes with virtual methods should have), this
-    C++ instance invalidates the wrapper only when the overridden destructor is called.
+If the class has a virtual destructor (and C++ classes with virtual methods should have), this
+C++ instance invalidates the wrapper only when the overridden destructor is called.
 
-    An instance of the **shell** is created when created in Python. However,
-    when  the object is created in C++, like in a factory method or a parameter
-    to a virtual function like ``QObject::event(QEvent *)``, the wrapped object
-    is a C++ instance of the native class, not the **shell** one, and we cannot
-    know when it is destroyed.
+An instance of the **shell** is created when created in Python. However,
+when the object is created in C++, like in a factory method or a parameter
+to a virtual function like ``QObject::event(QEvent *)``, the wrapped object
+is a C++ instance of the native class, not the **shell** one, and we cannot
+know when it is destroyed.
 
 .. _ownership-parent:
 
@@ -108,45 +108,45 @@ for any C++ library with similar behavior.
 Parentship heuristics
 ---------------------
 
-    As the parent-child relationship is very common, |project| tries to automatically
-    infer what methods falls into the parent-child scheme, adding the extra
-    directives related to ownership.
+As the parent-child relationship is very common, |project| tries to automatically
+infer what methods falls into the parent-child scheme, adding the extra
+directives related to ownership.
 
-    This heuristic will be triggered when generating code for a method and:
+This heuristic will be triggered when generating code for a method and:
 
-    * The function is a constructor.
-    * The argument name is `parent`.
-    * The argument type is a pointer to an object.
+* The function is a constructor.
+* The argument name is `parent`.
+* The argument type is a pointer to an object.
 
-    When triggered, the heuristic will set the argument named "parent"
-    as the parent of the object being created by the constructor.
+When triggered, the heuristic will set the argument named "parent"
+as the parent of the object being created by the constructor.
 
-    The main focus of this process was to remove a lot of hand written code from
-    type system when binding Qt libraries. For Qt, this heuristic works in all cases,
-    but be aware that it might not when binding your own libraries.
+The main focus of this process was to remove a lot of hand written code from
+type system when binding Qt libraries. For Qt, this heuristic works in all cases,
+but be aware that it might not when binding your own libraries.
 
-    To activate this heuristic, use the :ref:`--enable-parent-ctor-heuristic <parent-heuristic>`
-    command line switch.
+To activate this heuristic, use the :ref:`--enable-parent-ctor-heuristic <parent-heuristic>`
+command line switch.
 
 .. _return-value-heuristics:
 
 Return value heuristics
 -----------------------
 
-    When enabled, object returned as pointer in C++ will become child of the object on which the method
-    was called.
+When enabled, object returned as pointer in C++ will become child of the object on which the method
+was called.
 
-    To activate this heuristic, use the command line switch
-    :ref:`--enable-return-value-heuristic <return-heuristic>`.
+To activate this heuristic, use the command line switch
+:ref:`--enable-return-value-heuristic <return-heuristic>`.
 
-    To disable this heuristic for specific cases, specify ``default`` as
-    ownership:
+To disable this heuristic for specific cases, specify ``default`` as
+ownership:
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <modify-argument index="0">
-            <define-ownership class="target" owner="default" />
-        </modify-argument>
+    <modify-argument index="0">
+        <define-ownership class="target" owner="default" />
+    </modify-argument>
 
 Common pitfalls
 ===============
@@ -154,32 +154,32 @@ Common pitfalls
 Not saving unowned objects references
 -------------------------------------
 
-    Sometimes when you pass an instance as argument to a method and the receiving
-    instance will need that object to live indefinitely, but will not take ownership
-    of the argument instance. In this case, you should hold a reference to the argument
-    instance.
+Sometimes when you pass an instance as argument to a method and the receiving
+instance will need that object to live indefinitely, but will not take ownership
+of the argument instance. In this case, you should hold a reference to the argument
+instance.
 
-    For example, let's say that you have a renderer class that will use a source class
-    in a setSource method but will not take ownership of it. The following code is wrong,
-    because when `render` is called the `Source` object created during the call to `setSource`
-    is already destroyed.
+For example, let's say that you have a renderer class that will use a source class
+in a setSource method but will not take ownership of it. The following code is wrong,
+because when `render` is called the `Source` object created during the call to `setSource`
+is already destroyed.
 
-    .. code-block:: python
+.. code-block:: python
 
-       renderer.setModel(Source())
-       renderer.render()
+   renderer.setModel(Source())
+   renderer.render()
 
-    To solve this, you should hold a reference to the source object, like in
+To solve this, you should hold a reference to the source object, like in
 
-    .. code-block:: python
+.. code-block:: python
 
-       source = Source()
-       renderer.setSource(source)
-       renderer.render()
+   source = Source()
+   renderer.setSource(source)
+   renderer.render()
 
 
-Ownership Management in  the Typesystem
-=======================================
+Ownership Management in the Typesystem
+======================================
 
 Python Wrapper Code
 -------------------
@@ -190,44 +190,44 @@ For this code, the ``class`` attribute takes the value ``target``
 Ownership transfer from C++ to target
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-    When an object currently owned by C++ has its ownership transferred
-    back to the target language, the binding can know for sure when the object will be deleted and
-    tie the C++ instance existence to the wrapper, calling the C++ destructor normally when the
-    wrapper is deleted.
+When an object currently owned by C++ has its ownership transferred
+back to the target language, the binding can know for sure when the object will be deleted and
+tie the C++ instance existence to the wrapper, calling the C++ destructor normally when the
+wrapper is deleted.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <modify-argument index="1">
-            <define-ownership class="target" owner="target" />
-        </modify-argument>
+    <modify-argument index="1">
+        <define-ownership class="target" owner="target" />
+    </modify-argument>
 
-    A typical use case would be returning an object allocated in C++, for
-    example from ``clone()`` or other factory methods.
+A typical use case would be returning an object allocated in C++, for
+example from ``clone()`` or other factory methods.
 
 Ownership transfer from target to C++
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-    In the opposite direction, when an object ownership is transferred from the target language
-    to C++, the native code takes full control of the object life and you don't
-    know when that object will be deleted, rendering the wrapper object invalid,
-    unless you're wrapping an object with a virtual destructor,
-    so you can override it and be notified of its destruction.
+In the opposite direction, when an object ownership is transferred from the target language
+to C++, the native code takes full control of the object life and you don't
+know when that object will be deleted, rendering the wrapper object invalid,
+unless you're wrapping an object with a virtual destructor,
+so you can override it and be notified of its destruction.
 
-    By default it's safer to just render the wrapper
-    object invalid and raise some error if the user tries to access
-    one of this objects members or pass it as argument to some function, to avoid unpleasant segfaults.
-    Also you should avoid calling the C++ destructor when deleting the wrapper.
+By default it's safer to just render the wrapper
+object invalid and raise some error if the user tries to access
+one of this objects members or pass it as argument to some function, to avoid unpleasant segfaults.
+Also you should avoid calling the C++ destructor when deleting the wrapper.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <modify-argument index="1">
-            <define-ownership class="target" owner="c++" />
-        </modify-argument>
+    <modify-argument index="1">
+        <define-ownership class="target" owner="c++" />
+    </modify-argument>
 
-    Use cases would be an returning a member object by pointer
-    or passing an object by pointer into a function where the class
-    takes ownership, for example
-    ``QNetworkAccessManager::setCookieJar(QNetworkCookieJar *)``.
+Use cases would be an returning a member object by pointer
+or passing an object by pointer into a function where the class
+takes ownership, for example
+``QNetworkAccessManager::setCookieJar(QNetworkCookieJar *)``.
 
 Parent-child relationship
 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -240,11 +240,11 @@ as long as the parent is, unless some other method can take the C++ ownership aw
 One of the main uses of this scheme is Qt's object system, with ownership among QObject-derived
 classes, creating "trees" of instances.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <modify-argument index="this">
-            <parent index="1" action="add"/>
-        </modify-argument>
+    <modify-argument index="this">
+        <parent index="1" action="add"/>
+    </modify-argument>
 
 In this example, the instance with the method that is being invoked (indicated by 'index="this"' on
 modify-argument) will be marked as a child
@@ -284,8 +284,8 @@ In this case, you should use the ``invalidate-after-use`` attribute in the
 :ref:`modify-argument` tag to mark the wrapper as invalid right after the
 virtual method returns.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <modify-argument index="2" invalidate-after-use="yes"/>
+    <modify-argument index="2" invalidate-after-use="yes"/>
 
 In this example the second argument will be invalidated after this method call.
diff --git a/sources/shiboken6/doc/typesystem_solving_compilation.rst b/sources/shiboken6/doc/typesystem_solving_compilation.rst
index 37771396b..705c2cd26 100644
--- a/sources/shiboken6/doc/typesystem_solving_compilation.rst
+++ b/sources/shiboken6/doc/typesystem_solving_compilation.rst
@@ -6,75 +6,75 @@ Solving compilation problems
 suppress-warning
 ^^^^^^^^^^^^^^^^
 
-    The generator will generate several warnings which may be irrelevant to the
-    user. The ``suppress-warning`` node suppresses the specified warning, and it is
-    a child of the :ref:`typesystem` node.
+The generator will generate several warnings which may be irrelevant to the
+user. The ``suppress-warning`` node suppresses the specified warning, and it is
+a child of the :ref:`typesystem` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <typesystem>
-            <suppress-warning text="..." />
-        </typesystem>
+    <typesystem>
+        <suppress-warning text="..." />
+    </typesystem>
 
-    The **text** attribute is the warning text to suppress, and may contain the *
-    wildcard (use "" to escape regular expression matching if the warning contain
-    a regular "*").
+The **text** attribute is the warning text to suppress, and may contain the *
+wildcard (use "" to escape regular expression matching if the warning contain
+a regular "*").
 
 .. _extra-includes:
 
 extra-includes
 ^^^^^^^^^^^^^^
 
-    The ``extra-includes`` node contains declarations of additional include files,
-    and it can be a child of the :ref:`namespace`, :ref:`value-type`,
-    :ref:`object-type` and :ref:`typesystem` and nodes.
+The ``extra-includes`` node contains declarations of additional include files,
+and it can be a child of the :ref:`namespace`, :ref:`value-type`,
+:ref:`object-type` and :ref:`typesystem` and nodes.
 
-    The generator automatically tries to read the global header for each type but
-    sometimes it is required to include extra files in the generated C++ code to
-    make sure that the code compiles. These files must be listed using include
-    nodes within the extra-include node:
+The generator automatically tries to read the global header for each type but
+sometimes it is required to include extra files in the generated C++ code to
+make sure that the code compiles. These files must be listed using include
+nodes within the extra-include node:
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <value-type>
-             <extra-includes>
-                 <include file-name="..." location="global | local"/>
-             </extra-includes>
-         </value-type>
+     <value-type>
+         <extra-includes>
+             <include file-name="..." location="global | local"/>
+         </extra-includes>
+     </value-type>
 
-    The **file-name** attribute is the file to include, such as "QStringList".
-    The **location** attribute is where the file is located: *global* means that
-    the file is located in $INCLUDEPATH and will be included using #include <...>,
-    *local* means that the file is in a local directory and will be included
-    using #include "...".
+The **file-name** attribute is the file to include, such as "QStringList".
+The **location** attribute is where the file is located: *global* means that
+the file is located in $INCLUDEPATH and will be included using #include <...>,
+*local* means that the file is in a local directory and will be included
+using #include "...".
 
-    When specified as a child of the :ref:`typesystem` node, the include
-    directives are added to the module source file which contains
-    the type converter and registration code. It can be used to specify
-    additional includes required for the converter code snippets.
+When specified as a child of the :ref:`typesystem` node, the include
+directives are added to the module source file which contains
+the type converter and registration code. It can be used to specify
+additional includes required for the converter code snippets.
 
 .. _include-element:
 
 include
 ^^^^^^^
 
-    The ``include`` node specifies the name and location of a file that must be
-    included, and it is a child of the :ref:`namespace`, :ref:`value-type`,
-    :ref:`object-type` or :ref:`extra-includes` node.
+The ``include`` node specifies the name and location of a file that must be
+included, and it is a child of the :ref:`namespace`, :ref:`value-type`,
+:ref:`object-type` or :ref:`extra-includes` node.
 
-    The generator automatically tries to read the global header for each type. Use
-    the include node to override this behavior, providing an alternative file. The
-    include node can also be used to specify extra include files.
+The generator automatically tries to read the global header for each type. Use
+the include node to override this behavior, providing an alternative file. The
+include node can also be used to specify extra include files.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <value-type>
-             <include file-name="..."
-                 location="global | local"/>
-         </value-type>
+     <value-type>
+         <include file-name="..."
+             location="global | local"/>
+     </value-type>
 
-    The **file-name** attribute is the file to include, such as "QStringList".
-    The **location** attribute is where the file is located: *global* means that
-    the file is located in $INCLUDEPATH and will be included using #include <...>,
-    *local* means that the file is in a local directory and will be included
-    using #include "...".
+The **file-name** attribute is the file to include, such as "QStringList".
+The **location** attribute is where the file is located: *global* means that
+the file is located in $INCLUDEPATH and will be included using #include <...>,
+*local* means that the file is in a local directory and will be included
+using #include "...".
diff --git a/sources/shiboken6/doc/typesystem_specialfunctions.rst b/sources/shiboken6/doc/typesystem_specialfunctions.rst
index 5c0c52663..78a6ff489 100644
--- a/sources/shiboken6/doc/typesystem_specialfunctions.rst
+++ b/sources/shiboken6/doc/typesystem_specialfunctions.rst
@@ -13,15 +13,15 @@ names, this is done using the :ref:`add-function` tag.
 
 The special function names are:
 
-    ============= =============================================== ==================== ===================
-    Function name Parameters                                      Return type          CPython equivalent
-    ============= =============================================== ==================== ===================
-    __len__       PyObject* self                                  Py_ssize_t           PySequence_Size
-    __getitem__   PyObject* self, Py_ssize_t _i                   PyObject*            PySequence_GetItem
-    __setitem__   PyObject* self, Py_ssize_t _i, PyObject* _value int                  PySequence_SetItem
-    __contains__  PyObject* self, PyObject* _value                int                  PySequence_Contains
-    __concat__    PyObject* self, PyObject* _other                PyObject*            PySequence_Concat
-    ============= =============================================== ==================== ===================
+============= =============================================== ==================== ===================
+Function name Parameters                                      Return type          CPython equivalent
+============= =============================================== ==================== ===================
+__len__       PyObject* self                                  Py_ssize_t           PySequence_Size
+__getitem__   PyObject* self, Py_ssize_t _i                   PyObject*            PySequence_GetItem
+__setitem__   PyObject* self, Py_ssize_t _i, PyObject* _value int                  PySequence_SetItem
+__contains__  PyObject* self, PyObject* _value                int                  PySequence_Contains
+__concat__    PyObject* self, PyObject* _other                PyObject*            PySequence_Concat
+============= =============================================== ==================== ===================
 
 You just need to inform the function name to the :ref:`add-function` tag, without any
 parameter or return type information, when you do it, |project| will create a C
@@ -47,8 +47,8 @@ in boolean expressions. In C++, this is commonly implemented as
 
 In Python, the function ``__bool__`` is used for this. shiboken can generate
 this functions depending on the command line options
-:ref:`--use-operator-bool-as-nb_nonzero <use-operator-bool-as-nb-nonzero>`
-and :ref:`--use-isnull-as-nb_nonzero <use-isnull-as-nb-nonzero>`,
+:ref:`--use-operator-bool-as-nb-bool <use-operator-bool-as-nb-bool>`
+and :ref:`--use-isnull-as-nb-bool <use-isnull-as-nb-bool>`,
 which can be overridden by specifying the boolean attributes
 **isNull** or **operator-bool** on the :ref:`value-type` or :ref:`object-type`
 elements in typesystem XML.
diff --git a/sources/shiboken6/doc/typesystem_specifying_types.rst b/sources/shiboken6/doc/typesystem_specifying_types.rst
index f7409f3b3..e979c4ee2 100644
--- a/sources/shiboken6/doc/typesystem_specifying_types.rst
+++ b/sources/shiboken6/doc/typesystem_specifying_types.rst
@@ -30,770 +30,838 @@ of the underlying parser.
 typesystem
 ^^^^^^^^^^
 
-    This is the root node containing all the type system information.
-    It may contain :ref:`add-function`, :ref:`container-type`,
-    :ref:`custom-type`, :ref:`enum-type`, :ref:`extra-includes`, :ref:`function`,
-    :ref:`load-typesystem`, :ref:`namespace`, :ref:`object-type`,
-    :ref:`primitive-type`, :ref:`rejection`, :ref:`smart-pointer-type`,
-    :ref:`suppress-warning`, :ref:`template`, :ref:`system_include`,
-    :ref:`typedef-type` or :ref:`value-type` child nodes.
+This is the root node containing all the type system information.
+It may contain :ref:`add-function`, :ref:`container-type`,
+:ref:`custom-type`, :ref:`enum-type`, :ref:`extra-includes`, :ref:`function`,
+:ref:`load-typesystem`, :ref:`namespace`, :ref:`object-type`,
+:ref:`opaque-container`,
+:ref:`primitive-type`, :ref:`rejection`, :ref:`smart-pointer-type`,
+:ref:`suppress-warning`, :ref:`template`, :ref:`system_include`,
+:ref:`typedef-type` or :ref:`value-type` child nodes.
 
-    It can have a number of attributes, described below.
+It can have a number of attributes, described below.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <typesystem package="..." default-superclass="..." allow-thread="..."
-                    exception-handling="..." snake-case="yes | no | both" >
-        </typesystem>
+    <typesystem package="..."
+                submodule-of="..."
+                allow-thread="..."
+                exception-handling="..."
+                snake-case="yes | no | both"
+                namespace-begin="..."
+                namespace-end="..." >
+    </typesystem>
+
+The **package** attribute is a string describing the package to be used,
+e.g. "QtCore".
 
-    The **package** attribute is a string describing the package to be used,
-    e.g. "QtCore".
-    The *optional* **default-superclass** attribute is the canonical C++ base class
-    name of all objects, e.g., "object".
+The *optional* **submodule-of** attribute specifies the name of a module to
+which the module is added as a sub-module. This requires adapting the
+installation directory of the module accordingly.
 
-    The *optional* attributes **allow-thread** and **exception-handling**
-    specify the default handling for the corresponding function modification
-    (see :ref:`modify-function`).
+The *optional* attributes **allow-thread** and **exception-handling**
+specify the default handling for the corresponding function modification
+(see :ref:`modify-function`).
 
-    The *optional* **snake-case** attribute specifies whether function
-    and field names will be automatically changed to the snake case
-    style that is common in Python (for example,  ``snakeCase`` will be
-    changed to ``snake_case``).
+The *optional* **snake-case** attribute specifies whether function
+and field names will be automatically changed to the snake case
+style that is common in Python (for example, ``snakeCase`` will be
+changed to ``snake_case``).
 
-    The value ``both`` means that the function or field will be exposed
-    under both its original name and the snake case version. There are
-    limitations to this though:
+The value ``both`` means that the function or field will be exposed
+under both its original name and the snake case version. There are
+limitations to this though:
 
-    - When overriding a virtual function of a C++ class in Python,
-      the snake case name must be used.
+- When overriding a virtual function of a C++ class in Python,
+  the snake case name must be used.
 
-    - When static and non-static overloads of a class member function
-      exist (as is the case for example for ``QFileInfo::exists()``),
-      the snake case name must be used.
+- When static and non-static overloads of a class member function
+  exist (as is the case for example for ``QFileInfo::exists()``),
+  the snake case name must be used.
+
+The *optional* **namespace-begin** and **namespace-end** attributes will be
+generated around the forward declarations in the module header. This is
+intended for libraries which can optionally use inline namespaces
+to allow for linking several versions of them together.
+For example, for *Qt*, one would specify ``QT_BEGIN_NAMESPACE``,
+``QT_END_NAMESPACE``, respectively.
 
 .. _load-typesystem:
 
 load-typesystem
 ^^^^^^^^^^^^^^^
 
-    The ``load-typesystem`` node specifies which type systems to load when mapping
-    multiple libraries to another language or basing one library on another, and
-    it is a child of the :ref:`typesystem` node.
+The ``load-typesystem`` node specifies which type systems to load when mapping
+multiple libraries to another language or basing one library on another, and
+it is a child of the :ref:`typesystem` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <typesystem>
-            <load-typesystem name="..." generate="yes | no" />
-        </typesystem>
+    <typesystem>
+        <load-typesystem name="..." generate="yes | no" />
+    </typesystem>
 
-    The **name** attribute is the filename of the typesystem to load, the
-    **generate** attribute specifies whether code should be generated or not. The
-    later must be specified when basing one library on another, making the generator
-    able to understand inheritance hierarchies, primitive mapping, parameter types
-    in functions, etc.
+The **name** attribute is the filename of the typesystem to load, the
+**generate** attribute specifies whether code should be generated or not. The
+later must be specified when basing one library on another, making the generator
+able to understand inheritance hierarchies, primitive mapping, parameter types
+in functions, etc.
 
-    Most libraries will be based on both the QtCore and QtGui modules, in which
-    case code generation for these libraries will be disabled.
+Most libraries will be based on both the QtCore and QtGui modules, in which
+case code generation for these libraries will be disabled.
 
 .. _rejection:
 
 rejection
 ^^^^^^^^^
 
-    The ``rejection`` node rejects the given class, or the specified function
-    or field, and it is a child of the :ref:`typesystem` node.
+The ``rejection`` node rejects the given class, or the specified function
+or field, and it is a child of the :ref:`typesystem` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <typesystem>
-            <rejection class="..."
-                function-name="..."
-                argument-type="..."
-                field-name="..." />
-        </typesystem>
+    <typesystem>
+        <rejection class="..."
+            function-name="..."
+            argument-type="..."
+            field-name="..." />
+    </typesystem>
 
-    The **class** attribute is the C++ class name of the class to reject. Use
-    the *optional* **function-name**, **argument-type**, or **field-name**
-    attributes to reject a particular function, function with arguments of a
-    particular type, or a field. Note that the **field-name** and
-    **function-name**/**argument-type** cannot be specified at the same time.
-    To remove all occurrences of a given field or function, set the class
-    attribute to \*.
+The **class** attribute is the C++ class name of the class to reject. Use
+the *optional* **function-name**, **argument-type**, or **field-name**
+attributes to reject a particular function, function with arguments of a
+particular type, or a field. Note that the **field-name** and
+**function-name**/**argument-type** cannot be specified at the same time.
+To remove all occurrences of a given field or function, set the class
+attribute to \*.
 
 .. _primitive-type:
 
 primitive-type
 ^^^^^^^^^^^^^^
 
-    The ``primitive-type`` node describes how a primitive type is mapped from C++ to
-    the target language, and is a child of the :ref:`typesystem` node. It may
-    contain :ref:`conversion-rule` child nodes. Note that most primitives are
-    already specified in the QtCore typesystem (see :ref:`primitive-cpp-types`).
-
-    .. code-block:: xml
-
-        <typesystem>
-            <primitive-type name="..."
-                since="..."
-                until="..."
-                target-lang-api-name="..."
-                default-constructor="..."
-                preferred-conversion="yes | no" />
-                view-on="..."
-        </typesystem>
+The ``primitive-type`` node describes how a primitive type is mapped from C++ to
+the target language, and is a child of the :ref:`typesystem` node. It may
+contain :ref:`conversion-rule` child nodes. Note that most primitives are
+already specified in the QtCore typesystem (see :ref:`primitive-cpp-types`).
 
-    The **name** attribute is the name of the primitive in C++.
+.. code-block:: xml
+
+    <typesystem>
+        <primitive-type name="..."
+            since="..."
+            until="..."
+            target-lang-api-name="..."
+            default-constructor="..."
+            preferred-conversion="yes | no"
+            view-on="..." />
+    </typesystem>
 
-    The optional **target-lang-api-name** attribute is the name of the
-    primitive type in the target language, defaulting to the **name** attribute.
+The **name** attribute is the name of the primitive in C++.
 
-    The *optional*  **since** value is used to specify the API version in which
-    the type was introduced.
+The optional **target-lang-api-name** attribute is the name of the
+primitive type in the target language, defaulting to the **name** attribute.
 
-    Similarly, the *optional*  **until** value can be used to specify the API
-    version in which the type will be obsoleted.
+The *optional* **since** value is used to specify the API version in which
+the type was introduced.
 
-    If the *optional* **preferred-conversion** attribute is set to *no*, it
-    indicates that this version of the primitive type is not the preferred C++
-    equivalent of the target language type. For example, in Python both "qint64"
-    and "long long" become "long" but we should prefer the "qint64" version. For
-    this reason we mark "long long" with preferred-conversion="no".
+Similarly, the *optional* **until** value can be used to specify the API
+version in which the type will be obsoleted.
 
-    The *optional* **default-constructor** specifies the minimal constructor
-    call to build one value of the primitive-type. This is not needed when the
-    primitive-type may be built with a default constructor (the one without
-    arguments).
+If the *optional* **preferred-conversion** attribute is set to *no*, it
+indicates that this version of the primitive type is not the preferred C++
+equivalent of the target language type. For example, in Python both "qint64"
+and "long long" become "long" but we should prefer the "qint64" version. For
+this reason we mark "long long" with preferred-conversion="no".
 
-    The *optional* **preferred-conversion** attribute tells how to build a default
-    instance of the primitive type. It should be a constructor call capable of
-    creating a instance of the primitive type. Example: a class "Foo" could have
-    a **preferred-conversion** value set to "Foo()". Usually this attribute is
-    used only for classes declared as primitive types and not for primitive C++
-    types, but that depends on the application using *ApiExtractor*.
+The *optional* **default-constructor** specifies the minimal constructor
+call to build one value of the primitive-type. This is not needed when the
+primitive-type may be built with a default constructor (the one without
+arguments).
 
-    The *optional* **view-on** attribute specifies that the type is a view
-    class like std::string_view or QStringView which has a constructor
-    accepting another type like std::string or QString. Since typically
-    no values can be assigned to view classes, no target-to-native conversion
-    can be generated for them. Instead, an instance of the viewed class should
-    be instantiated and passed to functions using the view class
-    for argument types.
+The *optional* **preferred-conversion** attribute tells how to build a default
+instance of the primitive type. It should be a constructor call capable of
+creating a instance of the primitive type. Example: a class "Foo" could have
+a **preferred-conversion** value set to "Foo()". Usually this attribute is
+used only for classes declared as primitive types and not for primitive C++
+types, but that depends on the application using *ApiExtractor*.
 
-    See :ref:`predefined_templates` for built-in templates for standard type
-    conversion rules.
+The *optional* **view-on** attribute specifies that the type is a view
+class like std::string_view or QStringView which has a constructor
+accepting another type like std::string or QString. Since typically
+no values can be assigned to view classes, no target-to-native conversion
+can be generated for them. Instead, an instance of the viewed class should
+be instantiated and passed to functions using the view class
+for argument types.
+
+See :ref:`predefined_templates` for built-in templates for standard type
+conversion rules.
 
 .. _namespace:
 
 namespace-type
 ^^^^^^^^^^^^^^
 
-    The ``namespace-type`` node maps the given C++ namespace to the target
-    language, and it is a child of the :ref:`typesystem` node or other
-    ``namespace-type`` nodes. It may contain :ref:`add-function`,
-    :ref:`declare-function`,  :ref:`enum-type`, :ref:`extra-includes`,
-    :ref:`include-element`,  :ref:`modify-function`, ``namespace-type``,
-    :ref:`object-type`, :ref:`smart-pointer-type`, :ref:`typedef-type` or :ref:`value-type`
-    child nodes.
-
-    .. code-block:: xml
-
-        <typesystem>
-            <namespace-type name="..."
-                visible="true | auto | false"
-                generate="yes | no"
-                generate-using="yes | no"
-                package="..."
-                since="..."
-                revision="..." />
-        </typesystem>
+The ``namespace-type`` node maps the given C++ namespace to the target
+language, and it is a child of the :ref:`typesystem` node or other
+``namespace-type`` nodes. It may contain :ref:`add-function`,
+:ref:`declare-function`, :ref:`enum-type`, :ref:`extra-includes`,
+:ref:`include-element`, :ref:`modify-function`, ``namespace-type``,
+:ref:`object-type`, :ref:`smart-pointer-type`, :ref:`typedef-type` or :ref:`value-type`
+child nodes.
+
+.. code-block:: xml
+
+    <typesystem>
+        <namespace-type name="..."
+            visible="true | auto | false"
+            generate="yes | no"
+            generate-using="yes | no"
+            package="..."
+            since="..."
+            extends = "..."
+            files = "..."
+            revision="..." />
+    </typesystem>
+
+The **name** attribute is the name of the namespace, e.g., "Qt".
+
+The *optional* **visible** attribute is used specify whether the
+namespace is visible in the target language name. Its default value is
+**auto**. It means that normal namespaces are visible, but inline namespaces
+(as introduced in C++ 11) will not be visible.
 
-    The **name** attribute is the name of the namespace, e.g., "Qt".
+The detection of inline namespaces requires shiboken to be built
+using LLVM 9.0.
 
-    The *optional* **visible** attribute is used specify whether the
-    namespace is visible in the target language name. Its default value is
-    **auto**. It means that normal namespaces are visible, but inline namespaces
-    (as introduced in C++ 11) will not be visible.
+The *optional* **generate** is a legacy attribute. Specifying
+**no** is equivalent to **visible="false"**.
 
-    The detection of inline namespaces requires shiboken to be built
-    using LLVM 9.0.
+The *optional* **generate-using** attribute specifies whether
+``using namespace`` is generated into the wrapper code for classes within
+the namespace (default: **yes**). This ensures for example that not fully
+qualified enumeration values of default argument values compile.
+However, in rare cases, it might cause ambiguities and can then be turned
+off.
 
-    The *optional* **generate** is a legacy attribute. Specifying
-    **no** is equivalent to **visible="false"**.
+The **package** attribute can be used to override the package of the type system.
 
-    The *optional* **generate-using** attribute specifies whether
-    ``using namespace`` is generated into the wrapper code for classes within
-    the namespace (default: **yes**). This ensures for example that not fully
-    qualified enumeration values of default argument values compile.
-    However, in rare cases, it might cause ambiguities and can then be turned
-    off.
+The *optional* **since** value is used to specify the API version of this type.
 
-    The **package** attribute can be used to override the package of the type system.
+The **revision** attribute can be used to specify a revision for each type, easing the
+production of ABI compatible bindings.
 
-    The *optional*  **since** value is used to specify the API version of this type.
+The *optional* **extends** attribute specifies the module name where the given
+namespace first occurs in case of a namespace spanning several modules. For
+example, in Qt, the namespace ``Qt`` first occurs in the ``QtCore`` module and
+is further populated in the ``QtGui`` module. ``QtGui.Qt`` will then be
+generated extending ``QtCore.Qt`` if **extends** is specified.
 
-    The **revision** attribute can be used to specify a revision for each type, easing the
-    production of ABI compatible bindings.
+The *optional* **file** attribute specifies a regular expression matching the
+include files whose contents are to be associated with the current module in
+case of a namespace spanning several modules.
 
 .. _enum-type:
 
 enum-type
 ^^^^^^^^^
 
-    The ``enum-type`` node maps the given enum from C++ to the target language,
-    and it is a child of the :ref:`typesystem` node. Use
-    :ref:`reject-enum-value` child nodes to reject values.
-
-    .. code-block:: xml
-
-        <typesystem>
-            <enum-type name="..."
-                identified-by-value="..."
-                class="yes | no"
-                since="..."
-                flags="yes | no"
-                flags-revision="..."
-                cpp-type = "..."
-                python-type = "IntEnum | IntFlag"
-                lower-bound="..."
-                upper-bound="..."
-                force-integer="yes | no"
-                extensible="yes | no"
-                revision="..." />
-        </typesystem>
+The ``enum-type`` node maps the given enum from C++ to the target language,
+and it is a child of the :ref:`typesystem` node. Use
+:ref:`reject-enum-value` child nodes to reject values.
+
+.. code-block:: xml
+
+    <typesystem>
+        <enum-type name="..."
+            identified-by-value="..."
+            class="yes | no"
+            since="..."
+            flags="yes | no"
+            flags-revision="..."
+            cpp-type = "..."
+            doc-file = "..."
+            python-type = "IntEnum | IntFlag"
+            lower-bound="..."
+            upper-bound="..."
+            force-integer="yes | no"
+            extensible="yes | no"
+            revision="..." />
+    </typesystem>
+
+The **name** attribute is the fully qualified C++ name of the enum
+(e.g.,"Qt::FillRule"). If the *optional* **flags** attribute is set to *yes*
+(the default is *no*), the generator will expect an existing QFlags<T> for the
+given enum type. The **lower-bound** and **upper-bound** attributes are used
+to specify runtime bounds checking for the enum value. The value must be a
+compilable target language statement, such as "QGradient.Spread.PadSpread"
+(taking again Python as an example). If the **force-integer** attribute is
+set to *yes* (the default is *no*), the generated target language code will
+use the target language integers instead of enums. And finally, the
+**extensible** attribute specifies whether the given enum can be extended
+with user values (the default is *no*).
 
-    The **name** attribute is the fully qualified C++ name of the enum
-    (e.g.,"Qt::FillRule"). If the *optional* **flags** attribute is set to *yes*
-    (the default is *no*), the generator will expect an existing QFlags<T> for the
-    given enum type. The **lower-bound** and **upper-bound** attributes are used
-    to specify runtime bounds checking for the enum value. The value must be a
-    compilable target language statement, such as "QGradient.Spread.PadSpread"
-    (taking again Python as an example). If the **force-integer** attribute is
-    set to *yes* (the default is *no*), the generated target language code will
-    use the target language integers instead of enums. And finally, the
-    **extensible** attribute specifies whether the given enum can be extended
-    with user values (the default is *no*).
+The *optional*  **since** value is used to specify the API version of this type.
 
-    The *optional*  **since** value is used to specify the API version of this type.
+The attribute **identified-by-value** helps to specify anonymous enums using the
+name of one of their values, which is unique for the anonymous enum scope.
+Notice that the **enum-type** tag can either have **name** or **identified-by-value**
+but not both.
 
-    The attribute **identified-by-value** helps to specify anonymous enums using the
-    name of one of their values, which is unique for the anonymous enum scope.
-    Notice that the **enum-type** tag can either have **name** or **identified-by-value**
-    but not both.
+The *optional* **python-type** attribute specifies the underlying
+Python type.
 
-    The *optional* **python-type** attribute specifies the underlying
-    Python type.
+The *optional* **cpp-type** attribute specifies a C++ to be used for
+casting values. This can be useful for large values triggering MSVC
+signedness issues.
 
-    The *optional* **cpp-type** attribute specifies a C++ to be used for
-    casting values. This can be useful for large values triggering MSVC
-    signedness issues.
+The *optional* **doc-file** attribute specifies the base name of the C++ or
+``.qdoc`` file indicated by ``\relates`` or ``\headerfile`` in ``qdoc``, to
+which the documentation of the enumeration is to be added and displayed in the
+case its a global enumeration. This attribute is for ``qdoc`` only.
 
-    The **revision** attribute can be used to specify a revision for each type, easing the
-    production of ABI compatible bindings.
+The **revision** attribute can be used to specify a revision for each type, easing the
+production of ABI compatible bindings.
 
-    The **flags-revision** attribute has the same purposes of **revision** attribute but
-    is used for the QFlag related to this enum.
+The **flags-revision** attribute has the same purposes of **revision** attribute but
+is used for the QFlag related to this enum.
 
 .. _reject-enum-value:
 
 reject-enum-value
 ^^^^^^^^^^^^^^^^^
 
-    The ``reject-enum-value`` node rejects the enum value specified by the
-    **name** attribute, and it is a child of the :ref:`enum-type` node.
+The ``reject-enum-value`` node rejects the enum value specified by the
+**name** attribute, and it is a child of the :ref:`enum-type` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <enum-type>
-             <reject-enum-value name="..."/>
-         </enum-type>
+     <enum-type>
+         <reject-enum-value name="..."/>
+     </enum-type>
 
-    This node is used when a C++ enum implementation has several identical numeric
-    values, some of which are typically obsolete.
+This node is used when a C++ enum implementation has several identical numeric
+values, some of which are typically obsolete.
 
 .. _value-type:
 
 value-type
 ^^^^^^^^^^
 
-    The ``value-type`` node indicates that the given C++ type is mapped onto the target
-    language as a value type. This means that it is an object passed by value on C++,
-    i.e. it is stored in the function call stack. It is a child of the :ref:`typesystem`
-    node or other type nodes and may contain :ref:`add-function`, :ref:`add-pymethoddef`,
-    :ref:`declare-function`, :ref:`conversion-rule`, :ref:`enum-type`,
-    :ref:`extra-includes`, :ref:`include-element`, :ref:`modify-function`,
-    :ref:`object-type`, :ref:`smart-pointer-type`, :ref:`typedef-type` or further
-    ``value-type`` child nodes.
-
-    .. code-block:: xml
-
-        <typesystem>
-            <value-type  name="..." since="..."
-             copyable="yes | no"
-             allow-thread="..."
-             disable-wrapper="yes | no"
-             exception-handling="..."
-             generate-functions="..."
-             isNull ="yes | no"
-             operator-bool="yes | no"
-             hash-function="..."
-             private="yes | no"
-             qt-register-metatype = "yes | no | base"
-             stream="yes | no"
-             default-constructor="..."
-             revision="..."
-             snake-case="yes | no | both" />
-        </typesystem>
+The ``value-type`` node indicates that the given C++ type is mapped onto the target
+language as a value type. This means that it is an object passed by value on C++,
+i.e. it is stored in the function call stack. It is a child of the :ref:`typesystem`
+node or other type nodes and may contain :ref:`add-function`, :ref:`add-pymethoddef`,
+:ref:`configuration-element`, :ref:`declare-function`, :ref:`conversion-rule`,
+:ref:`enum-type`, :ref:`extra-includes`, :ref:`include-element`, :ref:`modify-function`,
+:ref:`object-type`, :ref:`smart-pointer-type`, :ref:`typedef-type` or further
+``value-type`` child nodes.
+
+.. code-block:: xml
+
+    <typesystem>
+        <value-type name="..." since="..."
+         copyable="yes | no"
+         allow-thread="..."
+         disable-wrapper="yes | no"
+         exception-handling="..."
+         generate-functions="..."
+         isNull ="yes | no"
+         operator-bool="yes | no"
+         hash-function="..."
+         private="yes | no"
+         qt-register-metatype = "yes | no | base"
+         stream="yes | no"
+         default-constructor="..."
+         revision="..."
+         snake-case="yes | no | both" />
+    </typesystem>
 
-    The **name** attribute is the fully qualified C++ class name, such as
-    "QMatrix" or "QPainterPath::Element". The **copyable** attribute is used to
-    force or not specify if this type is copyable. The *optional* **hash-function**
-    attribute informs the function name of a hash function for the type.
+The **name** attribute is the fully qualified C++ class name, such as
+"QMatrix" or "QPainterPath::Element". The **copyable** attribute is used to
+force or not specify if this type is copyable. The *optional* **hash-function**
+attribute informs the function name of a hash function for the type.
 
-    The *optional* attribute **stream** specifies whether this type will be able to
-    use externally defined operators, like QDataStream << and >>. If equals to **yes**,
-    these operators will be called as normal methods within the current class.
+The *optional* attribute **stream** specifies whether this type will be able to
+use externally defined operators, like QDataStream << and >>. If equals to **yes**,
+these operators will be called as normal methods within the current class.
 
-    The *optional*  **since** value is used to specify the API version of this type.
+The *optional* **since** value is used to specify the API version of this type.
 
-    The *optional* **default-constructor** specifies the minimal constructor
-    call to build one instance of the value-type. This is not needed when the
-    value-type may be built with a default constructor (the one without arguments).
-    Usually a code generator may guess a minimal constructor for a value-type based
-    on its constructor signatures, thus **default-constructor** is used only in
-    very odd cases.
+The *optional* **default-constructor** specifies the minimal constructor
+call to build one instance of the value-type. This is not needed when the
+value-type may be built with a default constructor (the one without arguments).
+Usually a code generator may guess a minimal constructor for a value-type based
+on its constructor signatures, thus **default-constructor** is used only in
+very odd cases.
 
-    For the *optional* **disable-wrapper** and **generate-functions**
-    attributes, see :ref:`object-type`.
+For the *optional* **disable-wrapper** and **generate-functions**
+attributes, see :ref:`object-type`.
 
-    For the *optional* **private** attribute, see :ref:`private_types`.
+For the *optional* **private** attribute, see :ref:`private_types`.
 
-    The *optional* **qt-register-metatype** attribute determines whether
-    a Qt meta type registration is generated for ``name``. By
-    default, this is generated for non-abstract, default-constructible
-    types for usage in signals and slots.
-    The value ``base`` means that the registration will be generated for the
-    class in question but not for inheriting classes.  This allows for
-    restricting the registration to base classes of type hierarchies.
+The *optional* **qt-register-metatype** attribute determines whether
+a Qt meta type registration is generated for ``name``. By
+default, this is generated for non-abstract, default-constructible
+types for usage in signals and slots.
+The value ``base`` means that the registration will be generated for the
+class in question but not for inheriting classes. This allows for
+restricting the registration to base classes of type hierarchies.
 
-    The **revision** attribute can be used to specify a revision for each type, easing the
-    production of ABI compatible bindings.
+The **revision** attribute can be used to specify a revision for each type, easing the
+production of ABI compatible bindings.
 
-    The *optional* attributes **allow-thread** and **exception-handling**
-    specify the default handling for the corresponding function modification
-    (see :ref:`modify-function`).
+The *optional* attributes **allow-thread** and **exception-handling**
+specify the default handling for the corresponding function modification
+(see :ref:`modify-function`).
 
-    The *optional* **snake-case** attribute allows for overriding the value
-    specified on the **typesystem** element.
+The *optional* **snake-case** attribute allows for overriding the value
+specified on the **typesystem** element.
 
-    The *optional* **isNull** and **operator-bool** attributes can be used
-    to override the command line setting for generating bool casts
-    (see :ref:`bool-cast`).
+The *optional* **isNull** and **operator-bool** attributes can be used
+to override the command line setting for generating bool casts
+(see :ref:`bool-cast`).
 
 .. _object-type:
 
 object-type
 ^^^^^^^^^^^
 
-    The object-type node indicates that the given C++ type is mapped onto the target
-    language as an object type. This means that it is an object passed by pointer on
-    C++ and it is stored on the heap. It is a child of the :ref:`typesystem` node
-    or other type nodes and may contain :ref:`add-function`, :ref:`add-pymethoddef`,
-    :ref:`declare-function`, :ref:`enum-type`, :ref:`extra-includes`,
-    :ref:`include-element`, :ref:`modify-function`, ``object-type``,
-    :ref:`smart-pointer-type`, :ref:`typedef-type` or :ref:`value-type` child nodes.
-
-    .. code-block:: xml
-
-        <typesystem>
-            <object-type name="..."
-             since="..."
-             copyable="yes | no"
-             allow-thread="..."
-             disable-wrapper="yes | no"
-             exception-handling="..."
-             generate-functions="..."
-             force-abstract="yes | no"
-             hash-function="..."
-             isNull ="yes | no"
-             operator-bool="yes | no"
-             parent-management="yes | no"
-             polymorphic-id-expression="..."
-             polymorphic-name-function="..."
-             private="yes | no"
-             qt-register-metatype = "yes | no | base"
-             stream="yes | no"
-             revision="..."
-             snake-case="yes | no | both" />
-        </typesystem>
+The object-type node indicates that the given C++ type is mapped onto the target
+language as an object type. This means that it is an object passed by pointer on
+C++ and it is stored on the heap. It is a child of the :ref:`typesystem` node
+or other type nodes and may contain :ref:`add-function`, :ref:`add-pymethoddef`,
+:ref:`configuration-element`, :ref:`declare-function`, :ref:`enum-type`,
+:ref:`extra-includes`, :ref:`include-element`, :ref:`modify-function`,
+``object-type``, :ref:`smart-pointer-type`, :ref:`typedef-type` or
+:ref:`value-type` child nodes.
 
-    The **name** attribute is the fully qualified C++ class name. If there is no
-    C++ base class, the default-superclass attribute can be used to specify a
-    superclass for the given type, in the generated target language API. The
-    **copyable** and **hash-function** attributes are the same as described for
-    :ref:`value-type`.
-
-    The *optional* **force-abstract** attribute forces the class to be
-    abstract, disabling its instantiation. The generator will normally detect
-    this automatically unless the class inherits from an abstract base class
-    that is not in the type system.
-
-    The *optional* **disable-wrapper** attribute disables the generation of a
-    **C++ Wrapper** (see :ref:`codegenerationterminology`). This will
-    effectively disable overriding virtuals methods in Python for the class.
-    It can be used when the class cannot be instantiated from Python and
-    its virtual methods pose some problem for the code generator (by returning
-    references, or using a default value that cannot be generated for a
-    parameter, or similar).
-
-    For the *optional* **private** attribute, see :ref:`private_types`.
-
-    The *optional* **qt-register-metatype** attribute determines whether
-    a Qt meta type registration is generated for ``name *``. By
-    default, this is only generated for non-QObject types for usage
-    in signals and slots.
-    The value ``base`` means that the registration will be generated for the
-    class in question but not for inheriting classes.  This allows for
-    restricting the registration to base classes of type hierarchies.
-
-    The *optional* attribute **stream** specifies whether this type will be able to
-    use externally defined operators, like QDataStream << and >>. If equals to **yes**,
-    these operators will be called as normal methods within the current class.
-
-    The *optional*  **since** value is used to specify the API version of this type.
-
-    The **revision** attribute can be used to specify a revision for each type, easing the
-    production of ABI compatible bindings.
-
-    The *optional* attributes **allow-thread** and **exception-handling**
-    specify the default handling for the corresponding function modification
-    (see :ref:`modify-function`).
-
-    The *optional* **generate-functions** specifies a semicolon-separated
-    list of function names or minimal signatures to be generated.
-    This allows for restricting the functions for which bindings are generated.
-    This also applies to virtual functions; so, all abstract functions
-    need to be listed to prevent non-compiling code to be generated.
-    If nothing is specified, bindings for all suitable functions are
-    generated. Note that special functions (constructors, etc),
-    cannot be specified.
-
-    The *optional* **snake-case** attribute allows for overriding the value
-    specified on the **typesystem** element.
-
-    The *optional* **isNull** and **operator-bool** attributes can be used
-    to override the command line setting for generating bool casts
-    (see :ref:`bool-cast`).
-
-    The *optional* **parent-management** attribute specifies that the class is
-    used for building object trees consisting of parents and children, for
-    example, user interfaces like the ``QWidget`` classes. For those classes,
-    the heuristics enabled by :ref:`ownership-parent-heuristics` and
-    :ref:`return-value-heuristics` are applied to automatically set parent
-    relationships. Compatibility note: In shiboken 6, when no class of the
-    type system has this attribute set, the heuristics will be applied
-    to all classes. In shiboken 7, it will be mandatory to set the
-    attribute.
-
-    The *optional* **polymorphic-id-expression** attribute specifies an
-    expression checking whether a base class pointer is of the matching
-    type. For example, in a ``virtual eventHandler(BaseEvent *e)``
-    function, this is used to construct a Python wrapper matching
-    the derived class (for example, a ``MouseEvent`` or similar).
-
-    The *optional* **polymorphic-name-function** specifies the name of a
-    function returning the type name of a derived class on the base class
-    type entry. Normally, ``typeid(ptr).name()`` is used for this.
-    However, this fails if the type hierarchy does not have virtual functions.
-    In this case, a function is required which typically decides depending
-    on some type enumeration.
+.. code-block:: xml
+
+    <typesystem>
+        <object-type name="..."
+         since="..."
+         copyable="yes | no"
+         allow-thread="..."
+         disable-wrapper="yes | no"
+         exception-handling="..."
+         generate-functions="..."
+         force-abstract="yes | no"
+         hash-function="..."
+         isNull ="yes | no"
+         operator-bool="yes | no"
+         parent-management="yes | no"
+         polymorphic-id-expression="..."
+         polymorphic-name-function="..."
+         polymorphic-base="yes | no"
+         private="yes | no"
+         qt-metaobject="yes | no"
+         qt-register-metatype = "yes | no | base"
+         stream="yes | no"
+         revision="..."
+         snake-case="yes | no | both" />
+    </typesystem>
+
+The **name** attribute is the fully qualified C++ class name. If there is no
+C++ base class, the default-superclass attribute can be used to specify a
+superclass for the given type, in the generated target language API. The
+**copyable** and **hash-function** attributes are the same as described for
+:ref:`value-type`.
+
+The *optional* **force-abstract** attribute forces the class to be
+abstract, disabling its instantiation. The generator will normally detect
+this automatically unless the class inherits from an abstract base class
+that is not in the type system.
+
+The *optional* **disable-wrapper** attribute disables the generation of a
+**C++ Wrapper** (see :ref:`codegenerationterminology`). This will
+effectively disable overriding virtuals methods in Python for the class.
+It can be used when the class cannot be instantiated from Python and
+its virtual methods pose some problem for the code generator (by returning
+references, or using a default value that cannot be generated for a
+parameter, or similar).
+
+For the *optional* **private** attribute, see :ref:`private_types`.
+
+The *optional* **qt-metaobject** attribute specifies whether
+the special Qt virtual functions ``metaObject()``,
+``metaCall()``, and ``metaCast()`` are generated. For classes
+using dynamic meta objects, for example, ``QDBusInterface``,
+it can be turned off.
+
+The *optional* **qt-register-metatype** attribute determines whether
+a Qt meta type registration is generated for ``name *``. By
+default, this is only generated for non-QObject types for usage
+in signals and slots.
+The value ``base`` means that the registration will be generated for the
+class in question but not for inheriting classes. This allows for
+restricting the registration to base classes of type hierarchies.
+
+The *optional* attribute **stream** specifies whether this type will be able to
+use externally defined operators, like QDataStream << and >>. If equals to **yes**,
+these operators will be called as normal methods within the current class.
+
+The *optional* **since** value is used to specify the API version of this type.
+
+The **revision** attribute can be used to specify a revision for each type, easing the
+production of ABI compatible bindings.
+
+The *optional* attributes **allow-thread** and **exception-handling**
+specify the default handling for the corresponding function modification
+(see :ref:`modify-function`).
+
+The *optional* **generate-functions** specifies a semicolon-separated
+list of function names or minimal signatures to be generated.
+This allows for restricting the functions for which bindings are generated.
+This also applies to virtual functions; so, all abstract functions
+need to be listed to prevent non-compiling code to be generated.
+If nothing is specified, bindings for all suitable functions are
+generated. Note that special functions (constructors, etc),
+cannot be specified.
+
+The *optional* **snake-case** attribute allows for overriding the value
+specified on the **typesystem** element.
+
+The *optional* **isNull** and **operator-bool** attributes can be used
+to override the command line setting for generating bool casts
+(see :ref:`bool-cast`).
+
+The *optional* **parent-management** attribute specifies that the class is
+used for building object trees consisting of parents and children, for
+example, user interfaces like the ``QWidget`` classes. For those classes,
+the heuristics enabled by :ref:`ownership-parent-heuristics` and
+:ref:`return-value-heuristics` are applied to automatically set parent
+relationships. Compatibility note: In shiboken 6, when no class of the
+type system has this attribute set, the heuristics will be applied
+to all classes. In shiboken 7, it will be mandatory to set the
+attribute.
+
+For the *optional* **polymorphic-id-expression**, **polymorphic-name-function**
+and **polymorphic-base** attributes, see :ref:`typediscovery-attributes`.
 
 interface-type
 ^^^^^^^^^^^^^^
 
-    This type is deprecated and no longer has any effect. Use object-type instead.
+This type is deprecated and no longer has any effect. Use object-type instead.
 
 .. _container-type:
 
 container-type
 ^^^^^^^^^^^^^^
 
-    The ``container-type`` node indicates that the given class is a container and
-    must be handled using one of the conversion helpers provided by attribute **type**.
-    It is a child of the :ref:`typesystem` node and may contain
-    :ref:`conversion-rule` child nodes.
+The ``container-type`` node indicates that the given class is a container and
+must be handled using one of the conversion helpers provided by attribute **type**.
+It is a child of the :ref:`typesystem` node and may contain
+:ref:`conversion-rule` child nodes.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <typesystem>
-            <container-type name="..."
-                since="..."
-                type ="..."
-                opaque-containers ="..." />
-        </typesystem>
+    <typesystem>
+        <container-type name="..."
+            since="..."
+            type ="..."
+            opaque-containers ="..." />
+    </typesystem>
+
+The **name** attribute is the fully qualified C++ class name. The **type**
+attribute is used to indicate what conversion rule will be applied to the
+container. It can be one of: *list*, *set*, *map*, *multi-map* or *pair*.
+
+Some types were deprecated in 6.2: *string-list*, *linked-list*, *vector*,
+*stack* and *queue* are equivalent to *list*. *hash* and *multi-hash*
+are equivalent to *map* and *multi-map*, respectively.
+
+The *optional* **opaque-containers** attribute specifies a semi-colon separated
+list of mappings from instantiations to a type name for
+:ref:`opaque-containers`:
 
-    The **name** attribute is the fully qualified C++ class name. The **type**
-    attribute is used to indicate what conversion rule will be applied to the
-    container. It can be one of: *list*, *set*, *map*, *multi-map* or *pair*.
+.. code-block:: xml
+
+    <typesystem>
+        <container-type name="std::array"
+                        opaque-containers ="int,3:IntArray3;float,4:FloatArray4">
+
+
+The *optional* **since** value is used to specify the API version of this container.
+
+Some common standard containers are :ref:`built-in <builtin-cpp-container-types>`,
+and there are also a number of useful
+:ref:`predefined conversion templates <predefined_templates>`.
+
+.. _opaque-container:
 
-    Some types were deprecated in 6.2: *string-list*, *linked-list*, *vector*,
-    *stack* and *queue* are equivalent to *list*. *hash* and *multi-hash*
-    are equivalent to *map* and *multi-map*, respectively.
+opaque-container
+^^^^^^^^^^^^^^^^
 
-    The *optional* **opaque-containers** attribute specifies a semi-colon separated
-    list of colon separated pairs of instantiation and name for
-    :ref:`opaque-containers`.
+The ``opaque-container`` element can be used to add further instantiations
+of :ref:`opaque containers <opaque-containers>` to existing container types
+(built-in or specified by :ref:`container-type` in included modules).
+It is a child of the :ref:`typesystem` node.
 
-    The *optional*  **since** value is used to specify the API version of this container.
+.. code-block:: xml
 
-    See :ref:`predefined_templates` for built-in templates for standard type
-    conversion rules.
+    <typesystem>
+        <oqaque-container name="..." opaque-containers ="..." />
+    </typesystem>
 
-    Some common standard containers (``std::list``, ``std::vector``, ``std::pair``,
-    ``std::map`` and ``std::unordered_map``) are built-in. They only need to be
-    specified if :ref:`opaque-containers` should be generated.
+For the **name** and **opaque-containers** attributes,
+see :ref:`container-type`.
 
 .. _typedef-type:
 
 typedef-type
 ^^^^^^^^^^^^
 
-    The ``typedef-type`` node allows for specifying typedefs in the typesystem. They
-    are mostly equivalent to spelling out the typedef in the included header, which
-    is often complicated when trying to wrap libraries whose source code cannot be
-    easily extended.
-    It is a child of the :ref:`typesystem` node or other type nodes.
+The ``typedef-type`` node allows for specifying typedefs in the typesystem. They
+are mostly equivalent to spelling out the typedef in the included header, which
+is often complicated when trying to wrap libraries whose source code cannot be
+easily extended.
+It is a child of the :ref:`typesystem` node or other type nodes.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <typesystem>
-            <typedef-type name="..."
-                source="..."
-                since="..." />
-        </typesystem>
+    <typesystem>
+        <typedef-type name="..."
+            source="..."
+            since="..." />
+    </typesystem>
 
-    The **source** attribute is the source. Example:
+The **source** attribute is the source. Example:
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <namespace-type name='std'>
-            <value-type name='optional' generate='no'/>\n"
-        </namespace-type>
-        <typedef-type name="IntOptional" source="std::optional&lt;int&gt;"/>
+    <namespace-type name='std'>
+        <value-type name='optional' generate='no'/>\n"
+    </namespace-type>
+    <typedef-type name="IntOptional" source="std::optional&lt;int&gt;"/>
 
-    is equivalent to
+is equivalent to
 
-    .. code-block:: c++
+.. code-block:: c++
 
-        typedef std::optional<int> IntOptional;
+    typedef std::optional<int> IntOptional;
 
-    The *optional*  **since** value is used to specify the API version of this type.
+The *optional* **since** value is used to specify the API version of this type.
 
 .. _custom-type:
 
 custom-type
 ^^^^^^^^^^^
 
-    The ``custom-type`` node simply makes the parser aware of the existence of a target
-    language type, thus avoiding errors when trying to find a type used in function
-    signatures and other places. The proper handling of the custom type is meant to
-    be done by a generator using the APIExractor.
-    It is a child of the :ref:`typesystem` node.
+The ``custom-type`` node simply makes the parser aware of the existence of a target
+language type, thus avoiding errors when trying to find a type used in function
+signatures and other places. The proper handling of the custom type is meant to
+be done by a generator using the APIExractor.
+It is a child of the :ref:`typesystem` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <typesystem>
-            <custom-type name="..."
-                check-function="..." />
-        </typesystem>
+    <typesystem>
+        <custom-type name="..."
+            check-function="..." />
+    </typesystem>
 
-    The **name** attribute is the name of the custom type, e.g., "PyObject".
+The **name** attribute is the name of the custom type, e.g., "PyObject".
 
-    The *optional*  **check-function** attribute can be used to specify a
-    boolean check function that verifies if the PyObject is of the given type
-    in the function overload decisor. While shiboken knows common check
-    functions like ``PyLong_Check()`` or ``PyType_Check()``, it might be useful
-    to provide one for function arguments modified to be custom types
-    handled by injected code (see :ref:`replace-type`).
+The *optional* **check-function** attribute can be used to specify a
+boolean check function that verifies if the PyObject is of the given type
+in the function overload decisor. While shiboken knows common check
+functions like ``PyLong_Check()`` or ``PyType_Check()``, it might be useful
+to provide one for function arguments modified to be custom types
+handled by injected code (see :ref:`replace-type`).
 
-    See :ref:`cpython-types` for built-in types.
+See :ref:`cpython-types` for built-in types.
 
 .. _smart-pointer-type:
 
 smart-pointer-type
 ^^^^^^^^^^^^^^^^^^
 
-    The ``smart pointer`` type node indicates that the given class is a smart pointer
-    and requires inserting calls to **getter** to access the pointeee.
-    Currently, the usage is limited to function return values.
-    **ref-count-method** specifies the name of the method used to do reference counting.
-    It is a child of the :ref:`typesystem` node or other type nodes.
-
-    The *optional* attribute **instantiations** specifies for which instantiations
-    of the smart pointer wrappers will be generated (comma-separated list).
-    By default, this will happen for all instantiations found by code parsing.
-    This might be a problem when linking different modules, since wrappers for the
-    same instantiation might be generated into different modules, which then clash.
-    Providing an instantiations list makes it possible to specify which wrappers
-    will be generated into specific modules.
-
-    .. code-block:: xml
-
-        <typesystem>
-            <smart-pointer-type name="..."
-                since="..."
-                type="shared | handle | value-handle | unique"
-                getter="..."
-                ref-count-method="..."
-                value-check-method="..."
-                null-check-method="..."
-                reset-method="..."
-                instantiations="..."/>
-            </typesystem>
-
-
-    The *optional* attribute **value-check-method** specifies a method
-    that can be used to check whether the pointer has a value.
-
-    The *optional* attribute **null-check-method** specifies a method
-    that can be used to check for ``nullptr``.
-
-    The *optional* attribute **reset-method** specifies a method
-    that can be used to clear the pointer.
-
-    The *optional* instantiations attribute specifies a comma-separated
-    list of instantiation types. When left empty, all instantiations
-    found in the code will be generated. The type name might optionally
-    be followed an equal sign and the Python type name, for example
-    ``instantiations="int=IntPtr,double=DoublePtr"``.
-    It is also possible to specify a namespace delimited by ``::``.
-
-    The *optional* attribute **type** specifies the type:
-
-    *shared*
-       A standard shared pointer.
-    *handle*
-       A basic pointer handle which has a getter function and an
-       ``operator->``.
-    *value-handle*
-       A handle which has a getter function returning a value
-       (``T`` instead of ``T *`` as for the other types).
-       It can be used for ``std::optional``.
-    *unique*
-       A standard, unique pointer (``std::unique_ptr``) or a similar
-       movable pointer.
-       Specifying the ``reset-method`` attribute is required for this work.
-
-    The example below shows an entry for a ``std::shared_ptr``:
-
-    .. code-block:: xml
+The ``smart pointer`` type node indicates that the given class is a smart pointer
+and requires inserting calls to **getter** to access the pointeee.
+Currently, the usage is limited to function return values.
+**ref-count-method** specifies the name of the method used to do reference counting.
+It is a child of the :ref:`typesystem` node or other type nodes.
 
-        <system-include file-name="memory"/>
+The *optional* attribute **instantiations** specifies for which instantiations
+of the smart pointer wrappers will be generated (comma-separated list).
+By default, this will happen for all instantiations found by code parsing.
+This might be a problem when linking different modules, since wrappers for the
+same instantiation might be generated into different modules, which then clash.
+Providing an instantiations list makes it possible to specify which wrappers
+will be generated into specific modules.
+
+.. code-block:: xml
+
+    <typesystem>
+        <smart-pointer-type name="..."
+            since="..."
+            type="shared | handle | value-handle | unique"
+            getter="..."
+            ref-count-method="..."
+            value-check-method="..."
+            null-check-method="..."
+            reset-method="..."
+            instantiations="..."/>
+        </typesystem>
+
+
+The *optional* attribute **value-check-method** specifies a method
+that can be used to check whether the pointer has a value.
 
-        <namespace-type name="std">
+The *optional* attribute **null-check-method** specifies a method
+that can be used to check for ``nullptr``.
+
+The *optional* attribute **reset-method** specifies a method
+that can be used to clear the pointer.
+
+The *optional* instantiations attribute specifies a comma-separated
+list of instantiation types. When left empty, all instantiations
+found in the code will be generated. The type name might optionally
+be followed an equal sign and the Python type name, for example
+``instantiations="int=IntPtr,double=DoublePtr"``.
+It is also possible to specify a namespace delimited by ``::``.
+By default, the type will be in the namespace of the smart pointer,
+for example, ``std`` for ``std::shared_ptr``. Preceding
+the type name by ``::`` causes it to be in the global namespace.
+
+The *optional* attribute **type** specifies the type:
+
+*shared*
+   A standard shared pointer.
+*handle*
+   A basic pointer handle which has a getter function and an
+   ``operator->``.
+*value-handle*
+   A handle which has a getter function returning a value
+   (``T`` instead of ``T *`` as for the other types).
+   It can be used for ``std::optional``.
+*unique*
+   A standard, unique pointer (``std::unique_ptr``) or a similar
+   movable pointer.
+   Specifying the ``reset-method`` attribute is required for this work.
+
+The example below shows an entry for a ``std::shared_ptr``:
+
+.. code-block:: xml
+
+    <system-include file-name="memory"/>
+
+    <namespace-type name="std">
+        <include file-name="memory" location="global"/>
+        <modify-function signature="^.*$" remove="all"/>
+        <enum-type name="pointer_safety"/>
+        <smart-pointer-type name="shared_ptr" type="shared" getter="get"
+                            ref-count-method="use_count"
+                            instantiations="Integer">
+            <include file-name="memory" location="global"/>
+        </smart-pointer-type>
+    </namespace-type>
+
+If the smart pointer is the only relevant class from namespace ``std``,
+it can also be hidden:
+
+.. code-block:: xml
+
+    <namespace-type name="std" visible="no">
+        <smart-pointer-type name="shared_ptr" type="shared" getter="get"
+                            ref-count-method="use_count"
+                            instantiations="Integer">
             <include file-name="memory" location="global"/>
-            <modify-function signature="^.*$" remove="all"/>
-            <enum-type name="pointer_safety"/>
-            <smart-pointer-type name="shared_ptr" type="shared" getter="get"
-                                ref-count-method="use_count"
-                                instantiations="Integer">
-                <include file-name="memory" location="global"/>
-            </smart-pointer-type>
-        </namespace-type>
-
-    If the smart pointer is the only relevant class from namespace ``std``,
-    it can also be hidden:
-
-    .. code-block:: xml
-
-        <namespace-type name="std" visible="no">
-            <smart-pointer-type name="shared_ptr" type="shared" getter="get"
-                                ref-count-method="use_count"
-                                instantiations="Integer">
-                <include file-name="memory" location="global"/>
-            </smart-pointer-type>
-        </namespace-type>
-
-    First, shiboken is told to actually parse the system include files
-    containing the class definition using the :ref:`system_include`
-    element. For the ``namespace-type`` and ``smart-pointer-type``, the
-    standard include files are given to override the internal implementation
-    header ``shared_ptr.h``.
-    This creates some wrapper sources which need to be added to the
-    ``CMakeLists.txt`` of the module.
+        </smart-pointer-type>
+    </namespace-type>
+
+First, shiboken is told to actually parse the system include files
+containing the class definition using the :ref:`system_include`
+element. For the ``namespace-type`` and ``smart-pointer-type``, the
+standard include files are given to override the internal implementation
+header ``shared_ptr.h``.
+This creates some wrapper sources which need to be added to the
+``CMakeLists.txt`` of the module.
 
 .. _function:
 
 function
 ^^^^^^^^
 
-    The ``function`` node indicates that the given C++ global function is mapped
-    onto the target language. It is a child of the :ref:`typesystem` node
-    and may contain a :ref:`modify-function` child node.
+The ``function`` node indicates that the given C++ global function is mapped
+onto the target language. It is a child of the :ref:`typesystem` node
+and may contain a :ref:`modify-function` child node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <typesystem>
-            <function signature="..." rename="..." since="..." snake-case="yes | no | both" />
-        </typesystem>
+    <typesystem>
+        <function signature="..." rename="..." since="..."
+                  allow-thread="true | auto | false"
+                  doc-file = "..."
+                  exception-handling="off | auto-off | auto-on | on"
+                  overload-number="number"
+                  snake-case="yes | no | both" />
+    </typesystem>
+
+There is a limitation; you cannot add a function overload using
+the :ref:`add-function` tag to an existent function.
 
-    There is a limitation; you cannot add a function overload using
-    the :ref:`add-function` tag to an existent function.
+The *optional* **since** attribute is used to specify the API version in which
+the function was introduced.
 
-    The *optional* **since** attribute is used to specify the API version in which
-    the function was introduced.
+The *optional* **rename** attribute is used to modify the function name.
 
-    The *optional* **rename** attribute is used to modify the function name.
+The *optional* **doc-file** attribute specifies the base name of the C++ or
+``.qdoc`` file indicated by ``\relates`` or ``\headerfile`` in ``qdoc``, to
+which the documentation of the function is to be added and displayed in the
+case its a global function. This attribute is for ``qdoc`` only.
 
-    The *optional* **snake-case** attribute allows for overriding the value
-    specified on the **typesystem** element.
+For the *optional* attributes **allow-thread**, **exception-handling**,
+**overload-number** and **snake-case**, see :ref:`modify-function`.
 
 .. _system_include:
 
 system-include
 ^^^^^^^^^^^^^^
 
-    The optional **system-include** specifies the name of a system include
-    file or a system include path (indicated by a trailing slash) to be
-    parsed. Normally, include files considered to be system include
-    files are skipped by the C++ code parser. Its primary use case
-    is exposing classes from the STL library.
-    It is a child of the :ref:`typesystem` node.
+The optional **system-include** specifies the name of a system include
+file or a system include path (indicated by a trailing slash) to be
+parsed. Normally, include files considered to be system include
+files are skipped by the C++ code parser. Its primary use case
+is exposing classes from the STL library.
+It is a child of the :ref:`typesystem` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <typesystem>
-            <system-include file-name="memory"/>
-            <system-include file-name="/usr/include/Qt/"/>
-        </typesystem>
+    <typesystem>
+        <system-include file-name="memory"/>
+        <system-include file-name="/usr/include/Qt/"/>
+    </typesystem>
 
 .. _conditional_processing:
 
 Conditional Processing
 ^^^^^^^^^^^^^^^^^^^^^^
 
-     Simple processing instructions are provided for including or excluding
-     sections depending on the presence of keywords. The syntax is:
+Simple processing instructions are provided for including or excluding
+sections depending on the presence of keywords. The syntax is:
 
-     .. code-block:: xml
+.. code-block:: xml
 
-         <?if keyword !excluded_keyword ?>
-            ...
-         <?endif?>
+    <?if keyword !excluded_keyword ?>
+       ...
+    <?endif?>
 
-     There are predefined keywords indicating the operating system (``windows``,
-     ``unix`` and ``darwin``).
+There are predefined keywords indicating the operating system (``windows``,
+``unix`` and ``darwin``).
 
-     The language level passed to the ``language-level`` command line option
-     is reflected as ``c++11``, ``c++14``, ``c++17`` or ``c++20``.
+The language level passed to the ``language-level`` command line option
+is reflected as ``c++11``, ``c++14``, ``c++17`` or ``c++20``.
 
-     The class names passed to the
-     :ref:`--drop-type-entries <drop-type-entries>` command line option
-     are also predefined, prefixed by ``no_``. This allows for example
-     for enclosing added functions referring to those classes within
-     ``<?if !no_ClassName?>``, ``<?endif?>``.
+The class names passed to the
+:ref:`--drop-type-entries <drop-type-entries>` command line option
+are also predefined, prefixed by ``no_``. This allows for example
+for enclosing added functions referring to those classes within
+``<?if !no_ClassName?>``, ``<?endif?>``.
 
-     Other keywords can be specified using the
-     :ref:`--keywords <conditional_keywords>` command line option.
+Other keywords can be specified using the
+:ref:`--keywords <conditional_keywords>` command line option.
 
 .. _private_types:
 
@@ -802,10 +870,10 @@ Defining Entities
 
 It is possible to define entities using a simple processing instruction:
 
-     .. code-block:: xml
+.. code-block:: xml
 
-         <?entity name value?>
-         <text>&name;</text>
+    <?entity name value?>
+    <text>&name;</text>
 
 This allows for defining function signatures depending on platform
 in conjunction with :ref:`conditional_processing`.
diff --git a/sources/shiboken6/doc/typesystem_templates.rst b/sources/shiboken6/doc/typesystem_templates.rst
index 22056b596..c32eb97d1 100644
--- a/sources/shiboken6/doc/typesystem_templates.rst
+++ b/sources/shiboken6/doc/typesystem_templates.rst
@@ -8,52 +8,52 @@ Using Code Templates
 template
 ^^^^^^^^
 
-    The ``template`` node registers a template that can be used to avoid
-    duplicate code when extending the generated code, and it is a child of the
-    :ref:`typesystem` node.
+The ``template`` node registers a template that can be used to avoid
+duplicate code when extending the generated code, and it is a child of the
+:ref:`typesystem` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <typesystem>
-            <template name="my_template">
-                // the code
-            </template>
-        </typesystem>
+    <typesystem>
+        <template name="my_template">
+            // the code
+        </template>
+    </typesystem>
 
-    Use the ``insert-template`` node to insert the template code (identified
-    by the template's ``name`` attribute) into the generated code base.
+Use the ``insert-template`` node to insert the template code (identified
+by the template's ``name`` attribute) into the generated code base.
 
 .. _insert-template:
 
 insert-template
 ^^^^^^^^^^^^^^^
 
-    The ``insert-template`` node includes the code template identified by the
-    name attribute, and it can be a child of the :ref:`inject-code`,
-    :ref:`conversion-rule` or :ref:`template` nodes.
+The ``insert-template`` node includes the code template identified by the
+name attribute, and it can be a child of the :ref:`inject-code`,
+:ref:`conversion-rule` or :ref:`template` nodes.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-         <inject-code class="target" position="beginning">
-             <insert-template name="my_template" />
-         </inject-code>
+     <inject-code class="target" position="beginning">
+         <insert-template name="my_template" />
+     </inject-code>
 
-    Use the ``replace`` node to modify the template code.
+Use the ``replace`` node to modify the template code.
 
 replace
 ^^^^^^^
 
-    The ``replace`` node allows you to modify template code before inserting it into
-    the generated code, and it can be a child of the :ref:`insert-template` node.
+The ``replace`` node allows you to modify template code before inserting it into
+the generated code, and it can be a child of the :ref:`insert-template` node.
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <insert-template name="my_template">
-           <replace from="..." to="..." />
-        </insert-template>
+    <insert-template name="my_template">
+       <replace from="..." to="..." />
+    </insert-template>
 
-    This node will replace the attribute ``from`` with the value pointed by
-    ``to``.
+This node will replace the attribute ``from`` with the value pointed by
+``to``.
 
 .. _predefined_templates:
 
@@ -65,49 +65,54 @@ built into shiboken.
 
 Templates for :ref:`primitive-type`:
 
-    +---------------------------------------+--------------------------------+
-    |Name                                   | Description                    |
-    +---------------------------------------+--------------------------------+
-    | ``shiboken_conversion_pylong_to_cpp`` | Convert a PyLong to a C++ type |
-    +---------------------------------------+--------------------------------+
++---------------------------------------+--------------------------------+
+|Name                                   | Description                    |
++---------------------------------------+--------------------------------+
+| ``shiboken_conversion_pylong_to_cpp`` | Convert a PyLong to a C++ type |
++---------------------------------------+--------------------------------+
 
 Templates for :ref:`container-type`:
 
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_pysequence_to_cpppair``                        | Convert a PySequence to a C++ pair (std::pair/QPair)                               |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_cpppair_to_pytuple``                           | Convert a C++ pair (std::pair/QPair) to a PyTuple                                  |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_cppsequence_to_pylist``                        | Convert a C++ sequential container to a PyList                                     |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_cppsequence_to_pyset``                         | Convert a C++ sequential container to a PySet                                      |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_pyiterable_to_cppsequentialcontainer``         | Convert an iterable Python type to a C++ sequential container (STL/Qt)             |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve`` | Convert an iterable Python type to a C++ sequential container supporting reserve() |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_pyiterable_to_cppsetcontainer``                | Convert a PySequence to a set-type C++ container (std::set/QSet)                   |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_stdmap_to_pydict``                             | Convert a std::map/std::unordered_map to a PyDict                                  |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_qmap_to_pydict``                               | Convert a QMap/QHash to a PyDict                                                   |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_pydict_to_stdmap``                             | Convert a PyDict to a std::map/std::unordered_map                                  |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_pydict_to_qmap``                               | Convert a PyDict to a QMap/QHash                                                   |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_stdmultimap_to_pydict``                        | Convert a std::multimap to a PyDict of value lists                                 |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_qmultimap_to_pydict``                          | Convert a QMultiMap to a PyDict of value lists                                     |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_stdunorderedmultimap_to_pydict``               | Convert a std::unordered_multimap to a PyDict of value lists                       |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_qmultihash_to_pydict``                         | Convert a QMultiHash to a PyDict of value lists                                    |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_pydict_to_stdmultimap``                        | Convert a PyDict of value lists to std::multimap/std::unordered_multimap           |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
-    | ``shiboken_conversion_pydict_to_qmultihash``                         | Convert a PyDict of value lists to QMultiMap/QMultiHash                            |
-    +----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+Some container types are :ref:`built-in <builtin-cpp-container-types>`.
+In case they need to explicitly specified, the following templates can be used:
+
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_pysequence_to_cpppair``                        | Convert a PySequence to a C++ pair (std::pair/QPair)                               |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_cpppair_to_pytuple``                           | Convert a C++ pair (std::pair/QPair) to a PyTuple                                  |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_cppsequence_to_pylist``                        | Convert a C++ sequential container to a PyList                                     |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_cppsequence_to_pyset``                         | Convert a C++ sequential container to a PySet                                      |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_pyiterable_to_cppsequentialcontainer``         | Convert an iterable Python type to a C++ sequential container (STL/Qt)             |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve`` | Convert an iterable Python type to a C++ sequential container supporting reserve() |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_pyiterable_to_cpparray``                       | Convert an iterable Python type to a fixed-size array (std::array, std::span)      |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_pyiterable_to_cppsetcontainer``                | Convert a PySequence to a set-type C++ container (std::set/QSet)                   |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_stdmap_to_pydict``                             | Convert a std::map/std::unordered_map to a PyDict                                  |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_qmap_to_pydict``                               | Convert a QMap/QHash to a PyDict                                                   |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_pydict_to_stdmap``                             | Convert a PyDict to a std::map/std::unordered_map                                  |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_pydict_to_qmap``                               | Convert a PyDict to a QMap/QHash                                                   |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_stdmultimap_to_pydict``                        | Convert a std::multimap to a PyDict of value lists                                 |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_qmultimap_to_pydict``                          | Convert a QMultiMap to a PyDict of value lists                                     |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_stdunorderedmultimap_to_pydict``               | Convert a std::unordered_multimap to a PyDict of value lists                       |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_qmultihash_to_pydict``                         | Convert a QMultiHash to a PyDict of value lists                                    |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_pydict_to_stdmultimap``                        | Convert a PyDict of value lists to std::multimap/std::unordered_multimap           |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
+| ``shiboken_conversion_pydict_to_qmultihash``                         | Convert a PyDict of value lists to QMultiMap/QMultiHash                            |
++----------------------------------------------------------------------+------------------------------------------------------------------------------------+
 
 An entry for the type ``std::list`` using these templates looks like:
 
@@ -126,9 +131,3 @@ An entry for the type ``std::list`` using these templates looks like:
             </target-to-native>
         </conversion-rule>
     </container-type>
-
-.. note:: From version 6.3, we do not have to explicitly specify the
-          `<container-type/>` for C++ containers ``std::list``\, ``std::vector``\,
-          ``std::pair``\, ``std::map`` and ``std::unordered_map``\. They are
-          now built-in. However, they still have to be added for opaque
-          containers or when modifying the built-in behavior.
diff --git a/sources/shiboken6/doc/typesystem_variables.rst b/sources/shiboken6/doc/typesystem_variables.rst
index c6564513b..d40891b9b 100644
--- a/sources/shiboken6/doc/typesystem_variables.rst
+++ b/sources/shiboken6/doc/typesystem_variables.rst
@@ -20,32 +20,30 @@ Variables
 .. _cpp_return_argument:
 
 **%0**
-
   Replaced by the C++ return variable of the Python method/function wrapper.
 
 
 .. _arg_number:
 
 **%<number>**
-
   Replaced by the name of a C++ argument in the position indicated by ``<number>``.
   The argument counting starts with ``%1``, since ``%0`` represents the return
   variable name. If the number indicates a variable that was removed in the
   type system description, but there is a default value for it, this value will
   be used. Consider this example:
 
-      .. code-block:: c++
+  .. code-block:: c++
 
-          void argRemoval(int a0, int a1 = 123);
+      void argRemoval(int a0, int a1 = 123);
 
 
-      .. code-block:: xml
+  .. code-block:: xml
 
-            <modify-function signature="argRemoval(int, int)">
-                <modify-argument index="2">
-                    <remove-argument/>
-                </modify-argument>
-            </modify-function>
+        <modify-function signature="argRemoval(int, int)">
+            <modify-argument index="2">
+                <remove-argument/>
+            </modify-argument>
+        </modify-function>
 
   The ``%1`` will be replaced by the C++ argument name, and ``%2`` will get the
   value ``123``.
@@ -54,7 +52,6 @@ Variables
 .. _argument_names:
 
 **%ARGUMENT_NAMES**
-
   Replaced by a comma separated list with the names of all C++ arguments that
   were not removed on the type system description for the method/function. When
   the removed argument has a default value (original or provided in the type
@@ -66,37 +63,36 @@ Variables
 
   Take the following method and related type system description as an example:
 
-      .. code-block:: c++
+  .. code-block:: c++
 
-          void argRemoval(int a0, Point a1 = Point(1, 2), bool a2 = true, Point a3 = Point(3, 4), int a4 = 56);
+      void argRemoval(int a0, Point a1 = Point(1, 2), bool a2 = true, Point a3 = Point(3, 4), int a4 = 56);
 
 
-      .. code-block:: xml
+  .. code-block:: xml
 
-            <modify-function signature="argRemoval(int, Point, bool, Point, int)">
-                <modify-argument index="2">
-                    <remove-argument/>
-                    <replace-default-expression with="Point(6, 9)"/>
-                </modify-argument>
-                <modify-argument index="4">
-                    <remove-argument/>
-                </modify-argument>
-            </modify-function>
+        <modify-function signature="argRemoval(int, Point, bool, Point, int)">
+            <modify-argument index="2">
+                <remove-argument/>
+                <replace-default-expression with="Point(6, 9)"/>
+            </modify-argument>
+            <modify-argument index="4">
+                <remove-argument/>
+            </modify-argument>
+        </modify-function>
 
   As seen on the XML description, the function's ``a1`` and ``a3`` arguments
   were removed. If any ``inject-code`` for this function uses ``%ARGUMENT_NAMES``
   the resulting list will be the equivalent of using individual argument type
   system variables this way:
 
-      .. code-block:: c++
+  .. code-block:: c++
 
-            %1, Point(6, 9), %3, Point(3, 4), %5
+        %1, Point(6, 9), %3, Point(3, 4), %5
 
 
 .. _arg_type:
 
 **%ARG#_TYPE**
-
   Replaced by the type of a C++ argument in the position indicated by ``#``.
   The argument counting starts with ``%1``, since ``%0`` represents the return
   variable in other contexts, but ``%ARG0_TYPE`` will not translate to the
@@ -104,18 +100,18 @@ Variables
   :ref:`%RETURN_TYPE <return_type>` variable.
   Example:
 
-      .. code-block:: c++
+  .. code-block:: c++
 
-          void argRemoval(int a0, int a1 = 123);
+      void argRemoval(int a0, int a1 = 123);
 
 
-      .. code-block:: xml
+  .. code-block:: xml
 
-            <modify-function signature="argRemoval(int, int)">
-                <modify-argument index="2">
-                    <remove-argument/>
-                </modify-argument>
-            </modify-function>
+        <modify-function signature="argRemoval(int, int)">
+            <modify-argument index="2">
+                <remove-argument/>
+            </modify-argument>
+        </modify-function>
 
   The ``%1`` will be replaced by the C++ argument name, and ``%2`` will get the
   value ``123``.
@@ -124,40 +120,38 @@ Variables
 .. _converttocpp:
 
 **%CONVERTTOCPP[CPPTYPE]**
-
   Replaced by a |project| conversion call that converts a Python variable
   to a C++ variable of the type indicated by ``CPPTYPE``.
 
-   Typically, this is a variable assignment:
+  Typically, this is a variable assignment:
 
-      .. code-block:: c++
+  .. code-block:: c++
 
-         double value = %CONVERTTOCPP[double](pyValue);
+     double value = %CONVERTTOCPP[double](pyValue);
 
-   Pointer assignments are also possible:
+  Pointer assignments are also possible:
 
-      .. code-block:: c++
+  .. code-block:: c++
 
-         void f(double *valuePtr)
-         {
-             *valuePtr = %CONVERTTOCPP[double](pyValue);
+     void f(double *valuePtr)
+     {
+         *valuePtr = %CONVERTTOCPP[double](pyValue);
 
-   Note however, that for variable definitions, the type must
-   be a space-delimited token:
+  Note however, that for variable definitions, the type must
+  be a space-delimited token:
 
-      .. code-block:: c++
+  .. code-block:: c++
 
-         double * valuePtr = %CONVERTTOCPP[double](pyValue);
+     double * valuePtr = %CONVERTTOCPP[double](pyValue);
 
-   since it otherwise would be indistinguishable from the pointer assignment
-   above.
+  since it otherwise would be indistinguishable from the pointer assignment
+  above.
 
-   It is possible to use "auto" as type.
+  It is possible to use "auto" as type.
 
 .. _converttopython:
 
 **%CONVERTTOPYTHON[CPPTYPE]**
-
   Replaced by a |project| conversion call that converts a C++ variable of the
   type indicated by ``CPPTYPE`` to the proper Python object.
 
@@ -165,7 +159,6 @@ Variables
 .. _isconvertible:
 
 **%ISCONVERTIBLE[CPPTYPE]**
-
   Replaced by a |project| "isConvertible" call that checks if a Python
   variable is convertible (via an implicit conversion or cast operator call)
   to a C++ variable of the type indicated by ``CPPTYPE``.
@@ -174,7 +167,6 @@ Variables
 .. _checktype:
 
 **%CHECKTYPE[CPPTYPE]**
-
   Replaced by a |project| "checkType" call that verifies if a Python
   if of the type indicated by ``CPPTYPE``.
 
@@ -182,14 +174,12 @@ Variables
 .. _cppself:
 
 **%CPPSELF**
-
   Replaced by the wrapped C++ object instance that owns the method in which the
   code with this variable was inserted.
 
 .. _cpptype:
 
 **%CPPTYPE**
-
   Replaced by the original name of the C++ class, without any namespace prefix,
   that owns the method in which the code with this variable was inserted. It will
   work on class level code injections also. Notice that ``CPPTYPE`` differs from
@@ -202,22 +192,18 @@ Variables
 .. _function_name:
 
 **%FUNCTION_NAME**
-
   Replaced by the name of a function or method.
 
 
-
 .. _py_return_argument:
 
 **%PYARG_0**
-
   Replaced by the name of the Python return variable of the Python method/function wrapper.
 
 
 .. _pyarg:
 
 **%PYARG_<number>**
-
   Similar to ``%<number>``, but is replaced by the Python arguments (PyObjects)
   received by the Python wrapper method.
 
@@ -228,16 +214,16 @@ Variables
 
   The example
 
-      .. code-block:: c++
+  .. code-block:: c++
 
-          long a = PyLong_AS_LONG(%PYARG_1);
+      long a = PyLong_AS_LONG(%PYARG_1);
 
 
   is equivalent of
 
-      .. code-block:: c++
+  .. code-block:: c++
 
-          long a = PyLong_AS_LONG(PyTuple_GET_ITEM(%PYTHON_ARGUMENTS, 0));
+      long a = PyLong_AS_LONG(PyTuple_GET_ITEM(%PYTHON_ARGUMENTS, 0));
 
 
   The generator tries to be smart with attributions, but it will work for the
@@ -245,24 +231,23 @@ Variables
 
   This example
 
-      .. code-block:: c++
+  .. code-block:: c++
 
-           Py_DECREF(%PYARG_1);
-           %PYARG_1 = PyLong_FromLong(10);
+       Py_DECREF(%PYARG_1);
+       %PYARG_1 = PyLong_FromLong(10);
 
 
   is equivalent of
 
-      .. code-block:: c++
+  .. code-block:: c++
 
-          Py_DECREF(PyTuple_GET_ITEM(%PYTHON_ARGUMENTS, 0));
-          PyTuple_SET_ITEM(%PYTHON_ARGUMENTS, 0, PyLong_FromLong(10));
+      Py_DECREF(PyTuple_GET_ITEM(%PYTHON_ARGUMENTS, 0));
+      PyTuple_SET_ITEM(%PYTHON_ARGUMENTS, 0, PyLong_FromLong(10));
 
 
 .. _pyself:
 
 **%PYSELF**
-
   Replaced by the Python wrapper variable (a PyObject) representing the instance
   bounded to the Python wrapper method which receives the custom code.
 
@@ -270,7 +255,6 @@ Variables
 .. _python_arguments:
 
 **%PYTHON_ARGUMENTS**
-
   Replaced by the pointer to the Python tuple with Python objects converted from
   the C++ arguments received on the binding override of a virtual method.
   This tuple is the same passed as arguments to the Python method overriding the
@@ -280,7 +264,6 @@ Variables
 .. _python_method_override:
 
 **%PYTHON_METHOD_OVERRIDE**
-
   This variable is used only on :ref:`native method code injections
   <codeinjecting_method_native>`, i.e. on the binding overrides for C++ virtual
   methods. It is replaced by a pointer to the Python method override.
@@ -289,7 +272,6 @@ Variables
 .. _pythontypeobject:
 
 **%PYTHONTYPEOBJECT**
-
   Replaced by the Python type object for the context in which it is inserted:
   method or class modification.
 
@@ -297,7 +279,6 @@ Variables
 .. _beginallowthreads:
 
 **%BEGIN_ALLOW_THREADS**
-
   Replaced by a thread state saving procedure.
   Must match with a :ref:`%END_ALLOW_THREADS <endallowthreads>` variable.
 
@@ -305,7 +286,6 @@ Variables
 .. _endallowthreads:
 
 **%END_ALLOW_THREADS**
-
   Replaced by a thread state restoring procedure.
   Must match with a :ref:`%BEGIN_ALLOW_THREADS <beginallowthreads>` variable.
 
@@ -313,14 +293,12 @@ Variables
 .. _return_type:
 
 **%RETURN_TYPE**
-
   Replaced by the type returned by a function or method.
 
 
 .. _type:
 
 **%TYPE**
-
   Replaced by the name of the class to which a function belongs. May be used
   in code injected at method or class level.
 
@@ -335,27 +313,27 @@ sections, below is an excerpt from the type system description of a |project|
 test. It changes a method that received ``argc/argv`` arguments into something
 that expects a Python sequence instead.
 
-    .. code-block:: xml
-
-        <modify-function signature="overloadedMethod(int, char**)">
-            <modify-argument index="1">
-                <replace-type modified-type="PySequence" />
-            </modify-argument>
-            <modify-argument index="2">
-                <remove-argument />
-            </modify-argument>
-            <inject-code class="target" position="beginning">
-                int argc;
-                char** argv;
-                if (!PySequence_to_argc_argv(%PYARG_1, &amp;argc, &amp;argv)) {
-                    PyErr_SetString(PyExc_TypeError, "error");
-                    return 0;
-                }
-                %RETURN_TYPE foo = %CPPSELF.%FUNCTION_NAME(argc, argv);
-                %0 = %CONVERTTOPYTHON[%RETURN_TYPE](foo);
-
-                for (int i = 0; i &lt; argc; ++i)
-                    delete[] argv[i];
-                delete[] argv;
-            </inject-code>
-        </modify-function>
+.. code-block:: xml
+
+    <modify-function signature="overloadedMethod(int, char**)">
+        <modify-argument index="1">
+            <replace-type modified-type="PySequence" />
+        </modify-argument>
+        <modify-argument index="2">
+            <remove-argument />
+        </modify-argument>
+        <inject-code class="target" position="beginning">
+            int argc;
+            char** argv;
+            if (!PySequence_to_argc_argv(%PYARG_1, &amp;argc, &amp;argv)) {
+                PyErr_SetString(PyExc_TypeError, "error");
+                return 0;
+            }
+            %RETURN_TYPE foo = %CPPSELF.%FUNCTION_NAME(argc, argv);
+            %0 = %CONVERTTOPYTHON[%RETURN_TYPE](foo);
+
+            for (int i = 0; i &lt; argc; ++i)
+                delete[] argv[i];
+            delete[] argv;
+        </inject-code>
+    </modify-function>
diff --git a/sources/shiboken6/generator/CMakeLists.txt b/sources/shiboken6/generator/CMakeLists.txt
index bac998ae5..aebe2cd5e 100644
--- a/sources/shiboken6/generator/CMakeLists.txt
+++ b/sources/shiboken6/generator/CMakeLists.txt
@@ -1,29 +1,46 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(shibokengenerator)
 set(package_name "Shiboken6Tools")
 
 set(CMAKE_AUTOMOC ON)
 
-if(NOT (Qt${QT_MAJOR_VERSION}Core_FOUND AND PYTHONINTERP_FOUND))
+if(NOT (Qt${QT_MAJOR_VERSION}Core_FOUND AND Python_Interpreter_FOUND))
     message(WARNING "Some dependencies were not found: shiboken6 generator compilation disabled!")
     return()
 endif()
 
 set(shiboken6_SRC
-generator.cpp
-generatorcontext.cpp
-defaultvalue.cpp
-shiboken/cppgenerator.cpp
-shiboken/cppgenerator_container.cpp
-shiboken/generatorargument.cpp
-shiboken/headergenerator.cpp
-shiboken/overloaddata.cpp
-shiboken/shibokengenerator.cpp
+defaultvalue.cpp defaultvalue.h
+generator.cpp generator.h
+generatorcontext.cpp generatorcontext.h
 main.cpp
+shiboken/configurablescope.h
+shiboken/cppgenerator.cpp shiboken/cppgenerator.h
+shiboken/cppgenerator_container.cpp
+shiboken/cppgenerator_smartpointer.cpp
+shiboken/ctypenames.h
+shiboken/generatorargument.cpp shiboken/generatorargument.h shiboken/generatorstrings.h
+shiboken/headergenerator.cpp shiboken/headergenerator.h
+shiboken/overloaddata.cpp shiboken/overloaddata.h
+shiboken/pytypenames.h
+shiboken/shibokengenerator.cpp shiboken/shibokengenerator.h
 )
 
+find_libclang()
+
+if(${STANDALONE})
+        list(APPEND CMAKE_INSTALL_RPATH ${base}/Qt/lib)
+else()
+        list(APPEND CMAKE_INSTALL_RPATH ${QT6_INSTALL_PREFIX}/${QT6_INSTALL_LIBS}
+             ${libclang_lib_dir})
+endif()
+
 add_executable(shiboken6 ${shiboken6_SRC})
 add_executable(Shiboken6::shiboken6 ALIAS shiboken6)
 add_dependencies(shiboken6 apiextractor)
+
 set_target_properties(shiboken6 PROPERTIES OUTPUT_NAME shiboken6${shiboken6_SUFFIX})
 target_include_directories(shiboken6 PRIVATE
                     ${CMAKE_CURRENT_SOURCE_DIR}/shiboken
@@ -32,9 +49,13 @@ target_include_directories(shiboken6 PRIVATE
                     ${CMAKE_CURRENT_BINARY_DIR}
                     ${apiextractor_SOURCE_DIR}
                     )
-target_link_libraries(shiboken6 apiextractor Qt${QT_MAJOR_VERSION}::Core)
+target_link_libraries(shiboken6 apiextractor Qt::Core)
 if (NOT DISABLE_DOCSTRINGS)
-    target_sources(shiboken6 PRIVATE qtdoc/qtxmltosphinx.cpp qtdoc/qtdocgenerator.cpp)
+    target_sources(shiboken6 PRIVATE
+                   qtdoc/qtdocgenerator.cpp qtdoc/qtdocgenerator.h
+                   qtdoc/qtxmltosphinx.cpp qtdoc/qtxmltosphinx.h
+                   qtdoc/qtxmltosphinxinterface.h
+                   qtdoc/rstformat.h)
     target_compile_definitions(shiboken6 PUBLIC DOCSTRINGS_ENABLED QT_LEAN_HEADERS=1)
 endif()
 
diff --git a/sources/shiboken6/generator/_config.py.in b/sources/shiboken6/generator/_config.py.in
index 985735fa4..ed7e67098 100644
--- a/sources/shiboken6/generator/_config.py.in
+++ b/sources/shiboken6/generator/_config.py.in
@@ -7,3 +7,4 @@ version_info = (@shiboken_MAJOR_VERSION@, @shiboken_MINOR_VERSION@, @shiboken_MI
 @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/shiboken6/generator/defaultvalue.cpp b/sources/shiboken6/generator/defaultvalue.cpp
index c3983a2e3..89cc9fa77 100644
--- a/sources/shiboken6/generator/defaultvalue.cpp
+++ b/sources/shiboken6/generator/defaultvalue.cpp
@@ -47,7 +47,7 @@ QString DefaultValue::returnValue() const
     case DefaultValue::Pointer:
         return u"nullptr"_s;
     case DefaultValue::Void:
-        return QString();
+        return {};
     case DefaultValue::DefaultConstructorWithDefaultValues:
         return m_value + u"()"_s;
     case DefaultValue::DefaultConstructor:
@@ -76,7 +76,7 @@ QString DefaultValue::initialization() const
     case DefaultValue::DefaultConstructorWithDefaultValues:
         break;
     }
-    return QString();
+    return {};
 }
 
 QString DefaultValue::constructorParameter() const
diff --git a/sources/shiboken6/generator/generator.cpp b/sources/shiboken6/generator/generator.cpp
index b1accb74b..a01326530 100644
--- a/sources/shiboken6/generator/generator.cpp
+++ b/sources/shiboken6/generator/generator.cpp
@@ -10,6 +10,7 @@
 #include "abstractmetafunction.h"
 #include "abstractmetalang.h"
 #include "messages.h"
+#include <optionsparser.h>
 #include "reporthandler.h"
 #include "fileout.h"
 #include "arraytypeentry.h"
@@ -29,8 +30,14 @@
 
 using namespace Qt::StringLiterals;
 
-static const char ENABLE_PYSIDE_EXTENSIONS[] = "enable-pyside-extensions";
-static const char AVOID_PROTECTED_HACK[] = "avoid-protected-hack";
+static constexpr auto ENABLE_PYSIDE_EXTENSIONS = "enable-pyside-extensions"_L1;
+static constexpr auto AVOID_PROTECTED_HACK = "avoid-protected-hack"_L1;
+
+struct GeneratorOptions
+{
+    bool usePySideExtensions = false;
+    bool avoidProtectedHack = false;
+};
 
 struct Generator::GeneratorPrivate
 {
@@ -40,10 +47,14 @@ struct Generator::GeneratorPrivate
     QString licenseComment;
     AbstractMetaClassCList m_invisibleTopNamespaces;
     bool m_hasPrivateClasses = false;
-    bool m_usePySideExtensions = false;
-    bool m_avoidProtectedHack = false;
+    static GeneratorOptions m_options;
 };
 
+GeneratorOptions Generator::GeneratorPrivate::m_options;
+
+// Kept as a variable for a potential Qt-in-namespace support
+QString Generator::m_gsp = "::"_L1;
+
 Generator::Generator() : m_d(new GeneratorPrivate)
 {
 }
@@ -66,10 +77,10 @@ bool Generator::setup(const ApiExtractorResult &api)
         return false;
     }
 
-    for (auto c : api.classes()) {
+    for (const auto &c : api.classes()) {
         if (c->enclosingClass() == nullptr && c->isInvisibleNamespace()) {
             m_d->m_invisibleTopNamespaces.append(c);
-            c->invisibleNamespaceRecursion([&](const AbstractMetaClass *ic) {
+            c->invisibleNamespaceRecursion([&](const AbstractMetaClassCPtr &ic) {
                 m_d->m_invisibleTopNamespaces.append(ic);
             });
         }
@@ -78,33 +89,51 @@ bool Generator::setup(const ApiExtractorResult &api)
     return doSetup();
 }
 
-Generator::OptionDescriptions Generator::options() const
+QList<OptionDescription> Generator::options()
 {
     return {
-        {QLatin1StringView(AVOID_PROTECTED_HACK),
+        {AVOID_PROTECTED_HACK,
          u"Avoid the use of the '#define protected public' hack."_s},
-        {QLatin1StringView(ENABLE_PYSIDE_EXTENSIONS),
+        {ENABLE_PYSIDE_EXTENSIONS,
          u"Enable PySide extensions, such as support for signal/slots,\n"
           "use this if you are creating a binding for a Qt-based library."_s}
     };
 }
 
-bool Generator::handleOption(const QString & key, const QString & /* value */)
+class GeneratorOptionsParser : public OptionsParser
+{
+public:
+    explicit GeneratorOptionsParser(GeneratorOptions *o) : m_options(o) {}
+
+    bool handleBoolOption(const QString &key, OptionSource source) override;
+
+private:
+    GeneratorOptions *m_options;
+};
+
+bool GeneratorOptionsParser::handleBoolOption(const QString & key, OptionSource source)
 {
-    if (key == QLatin1StringView(ENABLE_PYSIDE_EXTENSIONS))
-        return ( m_d->m_usePySideExtensions = true);
-    if (key == QLatin1StringView(AVOID_PROTECTED_HACK))
-        return (m_d->m_avoidProtectedHack = true);
+    if (source == OptionSource::CommandLineSingleDash)
+        return false;
+    if (key == ENABLE_PYSIDE_EXTENSIONS)
+        return ( m_options->usePySideExtensions = true);
+    if (key == AVOID_PROTECTED_HACK)
+        return ( m_options->avoidProtectedHack = true);
     return false;
 }
 
+std::shared_ptr<OptionsParser> Generator::createOptionsParser()
+{
+    return std::make_shared<GeneratorOptionsParser>(&GeneratorPrivate::m_options);
+}
+
 QString Generator::fileNameForContextHelper(const GeneratorContext &context,
                                             const QString &suffix,
                                             FileNameFlags flags)
 
 {
     if (!context.forSmartPointer()) {
-        const AbstractMetaClass *metaClass = context.metaClass();
+        const auto metaClass = context.metaClass();
         QString fileNameBase = flags.testFlag(FileNameFlag::UnqualifiedName)
             ? metaClass->name() : metaClass->qualifiedCppName();
         if (!flags.testFlag(FileNameFlag::KeepCase))
@@ -176,7 +205,7 @@ void Generator::setOutputDirectory(const QString &outDir)
 
 bool Generator::generateFileForContext(const GeneratorContext &context)
 {
-    const AbstractMetaClass *cls = context.metaClass();
+    const auto cls = context.metaClass();
     auto typeEntry = cls->typeEntry();
 
     if (!shouldGenerate(typeEntry))
@@ -202,23 +231,23 @@ QString Generator::getFileNameBaseForSmartPointer(const AbstractMetaType &smartP
     const AbstractMetaType innerType = smartPointerType.getSmartPointerInnerType();
     smartPointerType.typeEntry()->qualifiedCppName();
     QString fileName = smartPointerType.typeEntry()->qualifiedCppName().toLower();
-    fileName.replace(u"::"_s, u"_"_s);
-    fileName.append(u"_"_s);
+    fileName.append(u'_');
     fileName.append(innerType.name().toLower());
-
+    fileName.replace(u"::"_s, u"_"_s); // std::shared_ptr<std::string>
     return fileName;
 }
 
-GeneratorContext Generator::contextForClass(const AbstractMetaClass *c) const
+GeneratorContext Generator::contextForClass(const AbstractMetaClassCPtr &c) const
 {
     GeneratorContext result;
     result.m_metaClass = c;
     return result;
 }
 
-GeneratorContext Generator::contextForSmartPointer(const AbstractMetaClass *c,
-                                                   const AbstractMetaType &t,
-                                                   const AbstractMetaClass *pointeeClass)
+GeneratorContext
+    Generator::contextForSmartPointer(const AbstractMetaClassCPtr &c,
+                                      const AbstractMetaType &t,
+                                      const AbstractMetaClassCPtr &pointeeClass)
 {
     GeneratorContext result;
     result.m_metaClass = c;
@@ -230,7 +259,7 @@ GeneratorContext Generator::contextForSmartPointer(const AbstractMetaClass *c,
 
 bool Generator::generate()
 {
-    for (auto cls : m_d->api.classes()) {
+    for (const auto &cls : m_d->api.classes()) {
         if (!generateFileForContext(contextForClass(cls)))
             return false;
         auto te = cls->typeEntry();
@@ -239,7 +268,7 @@ bool Generator::generate()
     }
 
     for (const auto &smp: m_d->api.instantiatedSmartPointers()) {
-        const AbstractMetaClass *pointeeClass = nullptr;
+        AbstractMetaClassCPtr pointeeClass;
         const auto instantiatedType = smp.type.instantiations().constFirst().typeEntry();
         if (instantiatedType->isComplex()) // not a C++ primitive
             pointeeClass = AbstractMetaClass::findClass(m_d->api.classes(), instantiatedType);
@@ -266,24 +295,22 @@ bool Generator::hasPrivateClasses() const
     return m_d->m_hasPrivateClasses;
 }
 
-bool Generator::usePySideExtensions() const
+bool Generator::usePySideExtensions()
 {
-    return m_d->m_usePySideExtensions;
+    return GeneratorPrivate::m_options.usePySideExtensions;
 }
 
-bool Generator::avoidProtectedHack() const
+bool Generator::avoidProtectedHack()
 {
-    return m_d->m_avoidProtectedHack;
+    return GeneratorPrivate::m_options.avoidProtectedHack;
 }
 
 QString Generator::getFullTypeName(TypeEntryCPtr type)
 {
     QString result = type->qualifiedCppName();
     if (type->isArray())
-        type = qSharedPointerCast<const ArrayTypeEntry>(type)->nestedTypeEntry();
-    if (!isCppPrimitive(type))
-        result.prepend(u"::"_s);
-    return result;
+        type = std::static_pointer_cast<const ArrayTypeEntry>(type)->nestedTypeEntry();
+    return isCppPrimitive(type) ? result : addGlobalScopePrefix(result);
 }
 
 QString Generator::getFullTypeName(const AbstractMetaType &type)
@@ -293,7 +320,7 @@ QString Generator::getFullTypeName(const AbstractMetaType &type)
     if (type.isVoidPointer())
         return u"void*"_s;
     if (type.typeEntry()->isContainer())
-        return u"::"_s + type.cppSignature();
+        return addGlobalScopePrefix(type.cppSignature());
     QString typeName;
     if (type.typeEntry()->isComplex() && type.hasInstantiations())
         typeName = getFullTypeNameWithoutModifiers(type);
@@ -302,9 +329,11 @@ QString Generator::getFullTypeName(const AbstractMetaType &type)
     return typeName + QString::fromLatin1("*").repeated(type.indirections());
 }
 
-QString Generator::getFullTypeName(const AbstractMetaClass *metaClass)
+QString Generator::getFullTypeName(const AbstractMetaClassCPtr &metaClass)
 {
-    return u"::"_s + metaClass->qualifiedCppName();
+    const QString &qualName = metaClass->qualifiedCppName();
+    // Typedefs are generated into the global namespace
+    return metaClass->isTypeDef() ? qualName : addGlobalScopePrefix(qualName);
 }
 
 QString Generator::getFullTypeNameWithoutModifiers(const AbstractMetaType &type)
@@ -330,7 +359,7 @@ QString Generator::getFullTypeNameWithoutModifiers(const AbstractMetaType &type)
     }
     while (typeName.endsWith(u'*') || typeName.endsWith(u' '))
         typeName.chop(1);
-    return u"::"_s + typeName;
+    return addGlobalScopePrefix(typeName);
 }
 
 std::optional<DefaultValue>
@@ -359,13 +388,13 @@ std::optional<DefaultValue>
     if (type.isNativePointer())
         return DefaultValue(DefaultValue::Pointer, type.typeEntry()->qualifiedCppName());
     if (type.isPointer())
-        return DefaultValue(DefaultValue::Pointer, u"::"_s + type.typeEntry()->qualifiedCppName());
+        return DefaultValue(DefaultValue::Pointer, getFullTypeName(type.typeEntry()));
 
     if (type.typeEntry()->isSmartPointer())
         return minimalConstructor(api, type.typeEntry());
 
     if (type.typeEntry()->isComplex()) {
-        auto cType = qSharedPointerCast<const ComplexTypeEntry>(type.typeEntry());
+        auto cType = std::static_pointer_cast<const ComplexTypeEntry>(type.typeEntry());
         if (cType->hasDefaultConstructor())
             return DefaultValue(DefaultValue::Custom, cType->defaultConstructor());
         auto klass = AbstractMetaClass::findClass(api.classes(), cType);
@@ -404,12 +433,11 @@ std::optional<DefaultValue>
     }
 
     if (type->isEnum()) {
-        const auto enumEntry = qSharedPointerCast<const EnumTypeEntry>(type);
-        if (const auto nullValue = enumEntry->nullValue(); !nullValue.isNull())
+        const auto enumEntry = std::static_pointer_cast<const EnumTypeEntry>(type);
+        if (const auto nullValue = enumEntry->nullValue())
             return DefaultValue(DefaultValue::Enum, nullValue->name());
         return DefaultValue(DefaultValue::Custom,
-                            u"static_cast< ::"_s + type->qualifiedCppName()
-                            + u">(0)"_s);
+                            "static_cast< "_L1 + getFullTypeName(type) + ">(0)"_L1);
     }
 
     if (type->isFlags()) {
@@ -418,7 +446,7 @@ std::optional<DefaultValue>
     }
 
     if (type->isPrimitive()) {
-        QString ctor = qSharedPointerCast<const PrimitiveTypeEntry>(type)->defaultConstructor();
+        QString ctor = std::static_pointer_cast<const PrimitiveTypeEntry>(type)->defaultConstructor();
         // If a non-C++ (i.e. defined by the user) primitive type does not have
         // a default constructor defined by the user, the empty constructor is
         // heuristically returned. If this is wrong the build of the generated
@@ -455,13 +483,13 @@ static QString constructorCall(const QString &qualifiedCppName, const QStringLis
 
 std::optional<DefaultValue>
     Generator::minimalConstructor(const ApiExtractorResult &api,
-                                  const AbstractMetaClass *metaClass,
+                                  const AbstractMetaClassCPtr &metaClass,
                                   QString *errorString)
 {
     if (!metaClass)
         return {};
 
-    auto cType = qSharedPointerCast<const ComplexTypeEntry>(metaClass->typeEntry());
+    auto cType = std::static_pointer_cast<const ComplexTypeEntry>(metaClass->typeEntry());
     if (cType->hasDefaultConstructor())
         return DefaultValue(DefaultValue::Custom, cType->defaultConstructor());
 
@@ -501,8 +529,7 @@ std::optional<DefaultValue>
     for (auto it = candidates.cbegin(), end = candidates.cend(); it != end; ++it) {
         const AbstractMetaArgumentList &arguments = it.value()->arguments();
         QStringList args;
-        for (qsizetype i = 0, size = arguments.size(); i < size; ++i) {
-            const AbstractMetaArgument &arg = arguments.at(i);
+        for (const auto &arg : arguments) {
             if (arg.hasModifiedDefaultValueExpression()) {
                 args << arg.defaultValueExpression(); // Spell out modified values
                 break;
@@ -521,7 +548,7 @@ std::optional<DefaultValue>
 }
 
 QString Generator::translateType(AbstractMetaType cType,
-                                 const AbstractMetaClass *context,
+                                 const AbstractMetaClassCPtr &context,
                                  Options options) const
 {
     QString s;
@@ -537,20 +564,20 @@ QString Generator::translateType(AbstractMetaType cType,
     } else if (cType.isArray()) {
         s = translateType(*cType.arrayElementType(), context, options) + u"[]"_s;
     } else {
+        AbstractMetaType copyType = cType;
         if (options & Generator::ExcludeConst || options & Generator::ExcludeReference) {
-            AbstractMetaType copyType = cType;
-
             if (options & Generator::ExcludeConst)
                 copyType.setConstant(false);
-
             if (options & Generator::ExcludeReference)
                 copyType.setReferenceType(NoReference);
+        }
 
-            s = copyType.cppSignature();
-            if (!copyType.typeEntry()->isVoid() && !isCppPrimitive(copyType.typeEntry()))
-                s.prepend(u"::"_s);
-        } else {
-            s = cType.cppSignature();
+        s = copyType.cppSignature();
+        const auto te = copyType.typeEntry();
+        if (!te->isVoid() && !isCppPrimitive(te)) { // Add scope resolution
+            const auto pos = s.indexOf(te->qualifiedCppName()); // Skip const/volatile
+            Q_ASSERT(pos >= 0);
+            s.insert(pos, u"::"_s);
         }
     }
 
@@ -574,7 +601,6 @@ static const QHash<QString, QString> &pythonOperators()
         {u"operator++"_s, u"__iadd__"_s},
         {u"operator--"_s, u"__isub__"_s},
         {u"operator*="_s, u"__imul__"_s},
-        {u"operator/="_s, u"__idiv__"_s},
         {u"operator%="_s, u"__imod__"_s},
         // Bitwise operators
         {u"operator&"_s, u"__and__"_s},
@@ -595,7 +621,10 @@ static const QHash<QString, QString> &pythonOperators()
         {u"operator<"_s, u"__lt__"_s},
         {u"operator>"_s, u"__gt__"_s},
         {u"operator<="_s, u"__le__"_s},
-        {u"operator>="_s, u"__ge__"_s}
+        {u"operator>="_s, u"__ge__"_s},
+        // Conversion (note bool has special handling with heuristics)
+        {u"operator int"_s, u"__int__"_s},
+        {u"operator double"_s, u"__float__"_s}
     };
     return result;
 }
@@ -605,6 +634,11 @@ QString Generator::pythonOperatorFunctionName(const QString &cppOpFuncName)
     return pythonOperators().value(cppOpFuncName);
 }
 
+bool Generator::isPythonOperatorFunctionName(const QString &cppOpFuncName)
+{
+    return pythonOperators().contains(cppOpFuncName);
+}
+
 QString Generator::subDirectoryForPackage(QString packageNameIn) const
 {
     if (packageNameIn.isEmpty())
@@ -613,11 +647,21 @@ QString Generator::subDirectoryForPackage(QString packageNameIn) const
     return packageNameIn;
 }
 
+QString Generator::addGlobalScopePrefix(const QString &t)
+{
+    return t.startsWith("std::"_L1) ? t : m_gsp + t;
+}
+
+QString Generator::globalScopePrefix(const GeneratorContext &classContext)
+{
+    return classContext.useWrapper() ? QString{} : m_gsp;
+}
+
 template<typename T>
-static QString getClassTargetFullName_(const T *t, bool includePackageName)
+static QString getClassTargetFullName_(T t, bool includePackageName)
 {
     QString name = t->name();
-    const AbstractMetaClass *context = t->enclosingClass();
+    AbstractMetaClassCPtr context = t->enclosingClass();
     while (context) {
         // If the type was marked as 'visible=false' we should not use it in
         // the type name
@@ -634,12 +678,14 @@ static QString getClassTargetFullName_(const T *t, bool includePackageName)
     return name;
 }
 
-QString getClassTargetFullName(const AbstractMetaClass *metaClass, bool includePackageName)
+QString getClassTargetFullName(const AbstractMetaClassCPtr &metaClass,
+                               bool includePackageName)
 {
     return getClassTargetFullName_(metaClass, includePackageName);
 }
 
-QString getClassTargetFullName(const AbstractMetaEnum &metaEnum, bool includePackageName)
+QString getClassTargetFullName(const AbstractMetaEnum &metaEnum,
+                               bool includePackageName)
 {
     return getClassTargetFullName_(&metaEnum, includePackageName);
 }
diff --git a/sources/shiboken6/generator/generator.h b/sources/shiboken6/generator/generator.h
index 131ad427d..5b051b599 100644
--- a/sources/shiboken6/generator/generator.h
+++ b/sources/shiboken6/generator/generator.h
@@ -6,18 +6,23 @@
 
 #include <abstractmetalang_typedefs.h>
 #include <typedatabase_typedefs.h>
-#include <QtCore/QSharedPointer>
 #include <QtCore/QList>
 
+#include <memory>
 #include <optional>
 
+
 class ApiExtractorResult;
 class GeneratorContext;
 class DefaultValue;
+struct OptionDescription;
+class OptionsParser;
 class TextStream;
 
-QString getClassTargetFullName(const AbstractMetaClass *metaClass, bool includePackageName = true);
-QString getClassTargetFullName(const AbstractMetaEnum &metaEnum, bool includePackageName = true);
+QString getClassTargetFullName(const AbstractMetaClassCPtr &metaClass,
+                               bool includePackageName = true);
+QString getClassTargetFullName(const AbstractMetaEnum &metaEnum,
+                               bool includePackageName = true);
 QString getFilteredCppSignatureString(QString signature);
 
 /**
@@ -25,12 +30,11 @@ QString getFilteredCppSignatureString(QString signature);
  *   you must subclass this to create your own generators.
  */
 class Generator
-{
+{;
 public:
-    using OptionDescription = QPair<QString, QString>;
-    using OptionDescriptions = QList<OptionDescription>;
+    Q_DISABLE_COPY_MOVE(Generator)
 
-    /// Optiosn used around the generator code
+    /// Options used around the generator code
     enum Option {
         NoOption                 = 0x00000000,
         ExcludeConst             = 0x00000001,
@@ -56,8 +60,8 @@ public:
 
     bool setup(const ApiExtractorResult &api);
 
-    virtual OptionDescriptions options() const;
-    virtual bool handleOption(const QString &key, const QString &value);
+    static QList<OptionDescription> options();
+    static std::shared_ptr<OptionsParser> createOptionsParser();
 
     /// Returns the top namespace made invisible
     const AbstractMetaClassCList &invisibleTopNamespaces() const;
@@ -91,10 +95,10 @@ public:
     bool hasPrivateClasses() const;
 
     /// Returns true if the user enabled PySide extensions (command line option)
-    bool usePySideExtensions() const;
+    static bool usePySideExtensions();
     /// Returns true if the generated code should not use the
     /// "#define protected public" hack.
-    bool avoidProtectedHack() const;
+    static bool avoidProtectedHack();
 
     /**
      *  Retrieves the name of the currently processed module.
@@ -107,6 +111,7 @@ public:
     static QString moduleName();
 
     static QString pythonOperatorFunctionName(const QString &cppOpFuncName);
+    static bool isPythonOperatorFunctionName(const QString &cppOpFuncName);
 
 protected:
     /// Helper for determining the file name
@@ -120,10 +125,10 @@ protected:
     /// Returns all container types found by APIExtractor
     static ContainerTypeEntryCList containerTypes();
 
-    virtual GeneratorContext contextForClass(const AbstractMetaClass *c) const;
-    static GeneratorContext contextForSmartPointer(const AbstractMetaClass *c,
-                                                   const AbstractMetaType &t,
-                                                   const AbstractMetaClass *pointeeClass = nullptr);
+    virtual GeneratorContext contextForClass(const AbstractMetaClassCPtr &c) const;
+    static GeneratorContext
+        contextForSmartPointer(const AbstractMetaClassCPtr &c, const AbstractMetaType &t,
+                           const AbstractMetaClassCPtr &pointeeClass = {});
 
     /// Generates a file for given AbstractMetaClass or AbstractMetaType (smart pointer case).
     bool generateFileForContext(const GeneratorContext &context);
@@ -142,7 +147,7 @@ protected:
     *   \return the metatype translated to binding source format
     */
     QString translateType(AbstractMetaType metatype,
-                          const AbstractMetaClass *context,
+                          const AbstractMetaClassCPtr &context,
                           Options options = NoOption) const;
 
     /**
@@ -153,7 +158,7 @@ protected:
     // Returns the full name of the type.
     static QString getFullTypeName(TypeEntryCPtr type);
     static QString getFullTypeName(const AbstractMetaType &type);
-    static QString getFullTypeName(const AbstractMetaClass *metaClass);
+    static QString getFullTypeName(const AbstractMetaClassCPtr &metaClass);
 
     /**
      *  Returns the full qualified C++ name for an AbstractMetaType, but removing modifiers
@@ -175,7 +180,7 @@ protected:
                            QString *errorString = nullptr);
     static std::optional<DefaultValue>
         minimalConstructor(const ApiExtractorResult &api,
-                           const AbstractMetaClass *metaClass,
+                           const AbstractMetaClassCPtr &metaClass,
                            QString *errorString = nullptr);
 
     /**
@@ -209,6 +214,11 @@ protected:
     */
     virtual QString subDirectoryForPackage(QString packageName = QString()) const;
 
+    static QString addGlobalScopePrefix(const QString &t);
+    static QString globalScopePrefix(const GeneratorContext &classContext);
+
+    static QString m_gsp;
+
 private:
     struct GeneratorPrivate;
     GeneratorPrivate *m_d;
@@ -217,7 +227,7 @@ private:
 Q_DECLARE_OPERATORS_FOR_FLAGS(Generator::Options)
 Q_DECLARE_OPERATORS_FOR_FLAGS(Generator::FileNameFlags)
 
-using GeneratorPtr = QSharedPointer<Generator>;
+using GeneratorPtr = std::shared_ptr<Generator>;
 using Generators = QList<GeneratorPtr>;
 
 #endif // GENERATOR_H
diff --git a/sources/shiboken6/generator/generatorcontext.h b/sources/shiboken6/generator/generatorcontext.h
index 573f98758..2e58d4346 100644
--- a/sources/shiboken6/generator/generatorcontext.h
+++ b/sources/shiboken6/generator/generatorcontext.h
@@ -31,9 +31,9 @@ public:
 
     GeneratorContext() = default;
 
-    const AbstractMetaClass *metaClass() const { return m_metaClass; }
+    AbstractMetaClassCPtr metaClass() const { return m_metaClass; }
     const AbstractMetaType &preciseType() const { return m_preciseClassType; }
-    const AbstractMetaClass *pointeeClass() const { return m_pointeeClass; }
+    AbstractMetaClassCPtr pointeeClass() const { return m_pointeeClass; }
 
     bool forSmartPointer() const { return m_type == SmartPointer; }
     bool useWrapper() const { return m_type ==  WrappedClass; }
@@ -44,8 +44,8 @@ public:
     QString effectiveClassName() const;
 
 private:
-    const AbstractMetaClass *m_metaClass = nullptr;
-    const AbstractMetaClass *m_pointeeClass = nullptr;
+    AbstractMetaClassCPtr m_metaClass;
+    AbstractMetaClassCPtr m_pointeeClass;
     AbstractMetaType m_preciseClassType;
     QString m_wrappername;
     Type m_type = Class;
diff --git a/sources/shiboken6/generator/main.cpp b/sources/shiboken6/generator/main.cpp
index 5c9d9320c..9871df206 100644
--- a/sources/shiboken6/generator/main.cpp
+++ b/sources/shiboken6/generator/main.cpp
@@ -9,12 +9,13 @@
 
 #include <apiextractor.h>
 #include <apiextractorresult.h>
+#include <exception.h>
 #include <fileout.h>
 #include <messages.h>
+#include <optionsparser.h>
 #include <reporthandler.h>
 #include <typedatabase.h>
 
-#include <QtCore/QCoreApplication>
 #include <QtCore/QDir>
 #include <QtCore/QFile>
 #include <QtCore/QLibrary>
@@ -27,280 +28,8 @@
 
 using namespace Qt::StringLiterals;
 
-static const QChar clangOptionsSplitter = u',';
-static const QChar keywordsSplitter = u',';
-static const QChar dropTypeEntriesSplitter = u';';
-static const QChar apiVersionSplitter = u'|';
-
-static inline QString keywordsOption() { return QStringLiteral("keywords"); }
-static inline QString clangOptionOption() { return QStringLiteral("clang-option"); }
-static inline QString clangOptionsOption() { return QStringLiteral("clang-options"); }
-static inline QString compilerOption() { return QStringLiteral("compiler"); }
-static inline QString compilerPathOption() { return QStringLiteral("compiler-path"); }
-static inline QString platformOption() { return QStringLiteral("platform"); }
-static inline QString apiVersionOption() { return QStringLiteral("api-version"); }
-static inline QString dropTypeEntriesOption() { return QStringLiteral("drop-type-entries"); }
-static inline QString languageLevelOption() { return QStringLiteral("language-level"); }
-static inline QString includePathOption() { return QStringLiteral("include-paths"); }
-static inline QString frameworkIncludePathOption() { return QStringLiteral("framework-include-paths"); }
-static inline QString systemIncludePathOption() { return QStringLiteral("system-include-paths"); }
-static inline QString typesystemPathOption() { return QStringLiteral("typesystem-paths"); }
-static inline QString helpOption() { return QStringLiteral("help"); }
-static inline QString diffOption() { return QStringLiteral("diff"); }
-static inline QString useGlobalHeaderOption() { return QStringLiteral("use-global-header"); }
-static inline QString dryrunOption() { return QStringLiteral("dry-run"); }
-static inline QString skipDeprecatedOption() { return QStringLiteral("skip-deprecated"); }
-static inline QString printBuiltinTypesOption() { return QStringLiteral("print-builtin-types"); }
-
 static const char helpHint[] = "Note: use --help or -h for more information.\n";
-
-using OptionDescriptions = Generator::OptionDescriptions;
-
-struct CommandLineArguments
-{
-    void addToOptionsList(const QString &option,
-                          const QString &value);
-    void addToOptionsList(const QString &option,
-                          const QStringList &value);
-    void addToOptionsList(const QString &option,
-                          const QString &listValue,
-                          QChar separator);
-    void addToOptionsPathList(const QString &option,
-                              const QString &pathListValue)
-    {
-        addToOptionsList(option, pathListValue, QDir::listSeparator());
-    }
-
-    bool addCommonOption(const QString &option, const QString &value);
-
-    QVariantMap options; // string,stringlist for path lists, etc.
-    QStringList positionalArguments;
-};
-
-void CommandLineArguments::addToOptionsList(const QString &option,
-                                            const QString &value)
-{
-    auto it = options.find(option);
-    if (it == options.end()) {
-        options.insert(option, QVariant(QStringList(value)));
-    } else {
-        auto list = it.value().toStringList();
-        list += value;
-        options[option] = QVariant(list);
-    }
-}
-
-void CommandLineArguments::addToOptionsList(const QString &option,
-                                            const QStringList &value)
-{
-    auto it = options.find(option);
-    if (it == options.end()) {
-        options.insert(option, QVariant(value));
-    } else {
-        auto list = it.value().toStringList();
-        list += value;
-        options[option] = QVariant(list);
-    }
-}
-
-void CommandLineArguments::addToOptionsList(const QString &option,
-                                            const QString &listValue,
-                                            QChar separator)
-{
-    const auto newValues = listValue.split(separator, Qt::SkipEmptyParts);
-    addToOptionsList(option, newValues);
-}
-
-// Add options common to project file and command line
-bool CommandLineArguments::addCommonOption(const QString &option,
-                                           const QString &value)
-{
-    bool result = true;
-    if (option == compilerOption() || option == compilerPathOption()
-        || option == platformOption()) {
-        options.insert(option, value);
-    } else if (option == clangOptionOption()) {
-        options.insert(option, QStringList(value));
-    } else if (option == clangOptionsOption()) {
-        addToOptionsList(option, value, clangOptionsSplitter);
-    } else if (option == apiVersionOption()) {
-        addToOptionsList(option, value, apiVersionSplitter);
-    } else if (option == keywordsOption()) {
-        addToOptionsList(option, value, keywordsSplitter);
-    } else if (option == dropTypeEntriesOption()) {
-        addToOptionsList(option, value, dropTypeEntriesSplitter);
-    } else {
-        result = false;
-    }
-    return result;
-}
-
-static void printOptions(QTextStream &s, const OptionDescriptions &options)
-{
-    s.setFieldAlignment(QTextStream::AlignLeft);
-    for (const auto &od : options) {
-        if (!od.first.startsWith(u'-'))
-            s << "--";
-        s << od.first;
-        if (od.second.isEmpty()) {
-            s << ", ";
-        } else {
-            s << Qt::endl;
-            const auto lines = QStringView{od.second}.split(u'\n');
-            for (const auto &line : lines)
-                s << "        " << line << Qt::endl;
-            s << Qt::endl;
-        }
-    }
-}
-
-// Return the file command line option matching a project file keyword
-static QString projectFileKeywordToCommandLineOption(const QString &p)
-{
-    if (p == u"include-path")
-        return includePathOption(); // "include-paths", ...
-    if (p == u"framework-include-path")
-        return frameworkIncludePathOption();
-    if (p == u"typesystem-path")
-        return typesystemPathOption();
-    if (p == u"system-include-paths")
-        return systemIncludePathOption();
-    return {};
-}
-
-static void processProjectFileLine(const QByteArray &line, CommandLineArguments &args)
-{
-    if (line.isEmpty())
-        return;
-    const QString lineS = QString::fromUtf8(line);
-    const auto split = line.indexOf(u'=');
-    if (split < 0) {
-        args.options.insert(lineS, QString{});
-        return;
-    }
-
-    const QString key = lineS.left(split).trimmed();
-    const QString value = lineS.mid(split + 1).trimmed();
-    const QString fileOption = projectFileKeywordToCommandLineOption(key);
-    if (fileOption.isEmpty()) {
-        if (key == u"header-file") {
-            args.positionalArguments.prepend(value);
-        } else if (key == u"typesystem-file") {
-            args.positionalArguments.append(value);
-        } else {
-            args.options.insert(key, value);
-        }
-    } else {
-        // Add single line value to the path list
-        args.addToOptionsList(fileOption, QDir::toNativeSeparators(value));
-    }
-}
-
-static std::optional<CommandLineArguments>
-    processProjectFile(const QString &appName, QFile &projectFile)
-{
-    QByteArray line = projectFile.readLine().trimmed();
-    if (line.isEmpty() || line != "[generator-project]") {
-        std::cerr << qPrintable(appName) << ": first line of project file \""
-            << qPrintable(projectFile.fileName())
-            << "\" must be the string \"[generator-project]\"\n";
-        return {};
-    }
-
-    CommandLineArguments args;
-    while (!projectFile.atEnd())
-        processProjectFileLine(projectFile.readLine().trimmed(), args);
-    return args;
-}
-
-static std::optional<CommandLineArguments> getProjectFileArguments()
-{
-    QStringList arguments = QCoreApplication::arguments();
-    QString appName = arguments.constFirst();
-    arguments.removeFirst();
-
-    QString projectFileName;
-    for (const QString &arg : std::as_const(arguments)) {
-        if (arg.startsWith(u"--project-file")) {
-            int split = arg.indexOf(u'=');
-            if (split > 0)
-                projectFileName = arg.mid(split + 1).trimmed();
-            break;
-        }
-    }
-
-    if (projectFileName.isEmpty())
-        return CommandLineArguments{};
-
-    if (!QFile::exists(projectFileName)) {
-        std::cerr << qPrintable(appName) << ": Project file \""
-            << qPrintable(projectFileName) << "\" not found.\n";
-        return {};
-    }
-
-    QFile projectFile(projectFileName);
-    if (!projectFile.open(QIODevice::ReadOnly)) {
-        std::cerr << qPrintable(appName) << ": Cannot open project file \""
-            << qPrintable(projectFileName) << "\" : " << qPrintable(projectFile.errorString())
-            << '\n';
-        return {};
-    }
-    return processProjectFile(appName, projectFile);
-}
-
-static void getCommandLineArg(QString arg, int &argNum, CommandLineArguments &args)
-{
-    if (arg.startsWith(u"--")) {
-        arg.remove(0, 2);
-        const auto split = arg.indexOf(u'=');
-        if (split < 0) {
-            args.options.insert(arg, QString());
-            return;
-        }
-        const QString option = arg.left(split);
-        const QString value = arg.mid(split + 1).trimmed();
-        if (args.addCommonOption(option, value)) {
-        } else if (option == includePathOption() || option == frameworkIncludePathOption()
-                   || option == systemIncludePathOption() || option == typesystemPathOption()) {
-            // Add platform path-separator separated list value to path list
-            args.addToOptionsPathList(option, value);
-        } else {
-            args.options.insert(option, value);
-        }
-        return;
-    }
-    if (arg.startsWith(u'-')) {
-        arg.remove(0, 1);
-        if (arg.startsWith(u'I')) // Shorthand path arguments -I/usr/include...
-            args.addToOptionsPathList(includePathOption(), arg.mid(1));
-        else if (arg.startsWith(u'F'))
-            args.addToOptionsPathList(frameworkIncludePathOption(), arg.mid(1));
-        else if (arg.startsWith(u"isystem"))
-            args.addToOptionsPathList(systemIncludePathOption(), arg.mid(7));
-        else if (arg.startsWith(u'T'))
-            args.addToOptionsPathList(typesystemPathOption(), arg.mid(1));
-        else if (arg == u"h")
-            args.options.insert(helpOption(), QString());
-        else if (arg.startsWith(u"std="))
-            args.options.insert(languageLevelOption(), arg.mid(4));
-        else
-            args.options.insert(arg, QString());
-        return;
-    }
-    if (argNum < args.positionalArguments.size())
-        args.positionalArguments[argNum] = arg;
-    else
-        args.positionalArguments.append(arg);
-    ++argNum;
-}
-
-static void getCommandLineArgs(CommandLineArguments &args)
-{
-    const QStringList arguments = QCoreApplication::arguments();
-    int argNum = 0;
-    for (qsizetype i = 1, size = arguments.size(); i < size; ++i)
-        getCommandLineArg(arguments.at(i).trimmed(), argNum, args);
-}
+static const char appName[] = "shiboken";
 
 static inline Generators docGenerators()
 {
@@ -318,66 +47,57 @@ static inline Generators shibokenGenerators()
     return result;
 }
 
-static inline QString languageLevelDescription()
+struct CommonOptions
 {
-    return u"C++ Language level (c++11..c++17, default="_s
-        + QLatin1StringView(clang::languageLevelOption(clang::emulatedCompilerLanguageLevel()))
-        + u')';
-}
+    QString generatorSet;
+    QString licenseComment;
+    QString outputDirectory = u"out"_s;
+    QStringList headers;
+    QString typeSystemFileName;
+    bool help = false;
+    bool version = false;
+    bool diff = false;
+    bool dryRun = false;
+    bool logUnmatched = false;
+    bool printBuiltinTypes = false;
+};
 
-void printUsage()
+class CommonOptionsParser : public OptionsParser
 {
-    const QChar pathSplitter = QDir::listSeparator();
-    QTextStream s(stdout);
-    s << "Usage:\n  "
-      << "shiboken [options] header-file(s) typesystem-file\n\n"
-      << "General options:\n";
-    QString pathSyntax;
-    QTextStream(&pathSyntax) << "<path>[" << pathSplitter << "<path>"
-        << pathSplitter << "...]";
-    OptionDescriptions generalOptions = {
-        {u"api-version=<\"package mask\">,<\"version\">"_s,
-         u"Specify the supported api version used to generate the bindings"_s},
+public:
+    explicit CommonOptionsParser(CommonOptions *o) : m_options(o) {}
+
+    bool handleBoolOption(const QString &key, OptionSource source) override;
+    bool handleOption(const QString &key, const QString &value, OptionSource source) override;
+
+    static OptionDescriptions optionDescriptions();
+
+private:
+    CommonOptions *m_options;
+};
+
+OptionDescriptions CommonOptionsParser::optionDescriptions()
+{
+    return {
         {u"debug-level=[sparse|medium|full]"_s,
          u"Set the debug level"_s},
         {u"documentation-only"_s,
          u"Do not generates any code, just the documentation"_s},
-        {u"drop-type-entries=\"<TypeEntry0>[;TypeEntry1;...]\""_s,
-         u"Semicolon separated list of type system entries (classes, namespaces,\n"
-          "global functions and enums) to be dropped from generation."_s},
-        {keywordsOption() + QStringLiteral("=keyword1[,keyword2,...]"),
-         u"A comma-separated list of keywords for conditional typesystem parsing"_s},
-        {clangOptionOption(),
-         u"Option to be passed to clang"_s},
-        {clangOptionsOption(),
-         u"A comma-separated list of options to be passed to clang"_s},
-        {compilerOption() + u"=<type>"_s,
+        {u"compiler=<type>"_s,
          u"Emulated compiler type (g++, msvc, clang)"_s},
-        {platformOption() + u"=<name>"_s,
+        {u"platform=<name>"_s,
          u"Emulated platform (windows, darwin, unix)"_s},
-        {compilerPathOption() + u"=<file>"_s,
+        {u"compiler-path=<file>"_s,
          u"Path to the compiler for determining builtin include paths"_s},
-        {u"-F<path>"_s, {} },
-        {u"framework-include-paths="_s + pathSyntax,
-         u"Framework include paths used by the C++ parser"_s},
-        {u"-isystem<path>"_s, {} },
-        {u"system-include-paths="_s + pathSyntax,
-         u"System include paths used by the C++ parser"_s},
-        {useGlobalHeaderOption(),
-         u"Use the global headers in generated code."_s},
         {u"generator-set=<\"generator module\">"_s,
          u"generator-set to be used. e.g. qtdoc"_s},
-        {skipDeprecatedOption(),
-         u"Skip deprecated functions"_s},
-        {diffOption(), u"Print a diff of wrapper files"_s},
-        {dryrunOption(), u"Dry run, do not generate wrapper files"_s},
+        {u"diff"_s, u"Print a diff of wrapper files"_s},
+        {u"dry-run"_s, u"Dry run, do not generate wrapper files"_s},
         {u"-h"_s, {} },
-        {helpOption(), u"Display this help and exit"_s},
+        {u"help"_s, u"Display this help and exit"_s},
         {u"-I<path>"_s, {} },
-        {u"include-paths="_s + pathSyntax,
+        {u"include-paths="_s + OptionsParser::pathSyntax(),
         u"Include paths used by the C++ parser"_s},
-        {languageLevelOption() + u"=, -std=<level>"_s,
-         languageLevelDescription()},
         {u"license-file=<license-file>"_s,
          u"File used for copyright headers of generated files"_s},
         {u"no-suppress-warnings"_s,
@@ -388,339 +108,252 @@ void printUsage()
          u"text file containing a description of the binding project.\n"
           "Replaces and overrides command line arguments"_s},
         {u"silent"_s, u"Avoid printing any message"_s},
-        {u"-T<path>"_s, {} },
-        {u"typesystem-paths="_s + pathSyntax,
-         u"Paths used when searching for typesystems"_s},
-        {printBuiltinTypesOption(),
+        {u"print-builtin-types"_s,
          u"Print information about builtin types"_s},
         {u"version"_s,
          u"Output version information and exit"_s}
     };
-    printOptions(s, generalOptions);
-
-    const Generators generators = shibokenGenerators() + docGenerators();
-    for (const GeneratorPtr &generator : generators) {
-        const OptionDescriptions options = generator->options();
-        if (!options.isEmpty()) {
-            s << Qt::endl << generator->name() << " options:\n\n";
-            printOptions(s, generator->options());
+}
+
+bool CommonOptionsParser::handleBoolOption(const QString &key, OptionSource source)
+{
+    if (source == OptionSource::CommandLineSingleDash) {
+        if (key == u"h") {
+            m_options->help = true;
+            return true;
+        }
+        return false;
+    }
+
+    if (key == u"version") {
+        m_options->version = true;
+        return true;
+    }
+    if (key == u"help") {
+        m_options->help = true;
+        return true;
+    }
+    if (key == u"diff") {
+        FileOut::setDiff(true);
+        return true;
+    }
+    if (key == u"dry-run") {
+        FileOut::setDryRun(true);
+        return true;
+    }
+    if (key == u"silent") {
+        ReportHandler::setSilent(true);
+        return true;
+    }
+    if (key == u"log-unmatched") {
+        m_options->logUnmatched = true;
+        return true;
+    }
+    if (key == u"print-builtin-types") {
+        m_options->printBuiltinTypes = true;
+        return true;
+    }
+
+    return false;
+}
+
+bool CommonOptionsParser::handleOption(const QString &key, const QString &value,
+                                       OptionSource source)
+{
+    if (source == OptionSource::CommandLineSingleDash)
+        return false;
+
+    if (key == u"generator-set" || key == u"generatorSet" /* legacy */) {
+        m_options->generatorSet = value;
+        return true;
+    }
+    if (key == u"license-file") {
+        QFile licenseFile(value);
+        if (!licenseFile.open(QIODevice::ReadOnly))
+            throw Exception(msgCannotOpenForReading(licenseFile));
+        m_options->licenseComment = QString::fromUtf8(licenseFile.readAll());
+        return true;
+    }
+    if (key == u"debug-level") {
+        if (!ReportHandler::setDebugLevelFromArg(value))
+            throw Exception(u"Invalid debug level: "_s + value);
+        return true;
+    }
+    if (key == u"output-directory") {
+        m_options->outputDirectory = value;
+        return true;
+    }
+    if (key == u"compiler") {
+        if (!clang::setCompiler(value))
+            throw Exception(u"Invalid value \""_s + value + u"\" passed to --compiler"_s);
+        return true;
+    }
+    if (key == u"compiler-path") {
+        clang::setCompilerPath(value);
+        return true;
+    }
+    if (key == u"platform") {
+        if (!clang::setPlatform(value))
+            throw Exception(u"Invalid value \""_s + value + u"\" passed to --platform"_s);
+        return true;
+    }
+
+    if (source == OptionSource::ProjectFile) {
+        if (key == u"header-file") {
+            m_options->headers.append(value);
+            return true;
+        }
+        if (key == u"typesystem-file") {
+            m_options->typeSystemFileName = value;
+            return true;
         }
     }
+
+    return false;
+}
+
+void printUsage()
+{
+    const auto generatorOptions = Generator::options();
+
+    QTextStream s(stdout);
+    s << "Usage:\n  "
+        << "shiboken [options] header-file(s) typesystem-file\n\n"
+        << "General options:\n"
+        << CommonOptionsParser::optionDescriptions()
+        << ApiExtractor::options()
+        << TypeDatabase::options()
+        << "\nSource generator options:\n\n" << generatorOptions
+        << ShibokenGenerator::options();
+
+#ifdef DOCSTRINGS_ENABLED
+    s << "\nDocumentation Generator options:\n\n"
+        << generatorOptions << QtDocGenerator::options();
+#endif
 }
 
 static inline void printVerAndBanner()
 {
-    std::cout << "shiboken v" SHIBOKEN_VERSION << std::endl;
+    std::cout << appName << " v" << SHIBOKEN_VERSION << std::endl;
     std::cout << "Copyright (C) 2016 The Qt Company Ltd." << std::endl;
 }
 
-static inline void errorPrint(const QString &s)
+static inline void errorPrint(const QString &s, const QStringList &arguments)
 {
-    QStringList arguments = QCoreApplication::arguments();
-    arguments.pop_front();
-    std::cerr << "shiboken: " << qPrintable(s) << "\nCommand line:\n";
+    std::cerr << appName << ": " << qPrintable(s) << "\nCommand line:\n";
     for (const auto &argument : arguments)
         std::cerr << "    \"" << qPrintable(argument) << "\"\n";
 }
 
-static void parseIncludePathOption(const QString &option, HeaderType headerType,
-                                   CommandLineArguments &args,
-                                   ApiExtractor &extractor)
-{
-    const auto it = args.options.find(option);
-    if (it != args.options.end()) {
-        const auto includePathListList = it.value().toStringList();
-        args.options.erase(it);
-        for (const QString &s : includePathListList) {
-            auto path = QFile::encodeName(QDir::cleanPath(s));
-            extractor.addIncludePath(HeaderPath{path, headerType});
-        }
-    }
-}
-
-int shibokenMain(int argc, char *argv[])
+int shibokenMain(const QStringList &argV)
 {
     // PYSIDE-757: Request a deterministic ordering of QHash in the code model
     // and type system.
-    qSetGlobalQHashSeed(0);
-    // needed by qxmlpatterns
-    QCoreApplication app(argc, argv);
+    QHashSeed::setDeterministicGlobalSeed();
+
     ReportHandler::install();
     if (ReportHandler::isDebug(ReportHandler::SparseDebug))
-        qCInfo(lcShiboken()).noquote().nospace() << QCoreApplication::arguments().join(u' ');
+        qCInfo(lcShiboken()).noquote().nospace() << appName << ' ' << argV.join(u' ');
 
-    // Store command arguments in a map
-    const auto projectFileArgumentsOptional = getProjectFileArguments();
-    if (!projectFileArgumentsOptional.has_value())
-        return EXIT_FAILURE;
-
-    const CommandLineArguments projectFileArguments = projectFileArgumentsOptional.value();
-    CommandLineArguments args = projectFileArguments;
-    getCommandLineArgs(args);
-    Generators generators;
+    Options options;
+    options.setOptions(argV);
 
-    auto ait = args.options.find(u"version"_s);
-    if (ait != args.options.end()) {
-        args.options.erase(ait);
+    CommonOptions commonOptions;
+    {
+        CommonOptionsParser parser(&commonOptions);
+        parser.process(&options);
+    }
+    if (commonOptions.version) {
         printVerAndBanner();
         return EXIT_SUCCESS;
     }
-
-    QString generatorSet;
-    ait = args.options.find(u"generator-set"_s);
-    if (ait == args.options.end()) // Also check "generatorSet" command line argument for backward compatibility.
-        ait = args.options.find(u"generatorSet"_s);
-    if (ait != args.options.end()) {
-        generatorSet = ait.value().toString();
-        args.options.erase(ait);
+    if (commonOptions.help) {
+        printUsage();
+        return EXIT_SUCCESS;
     }
 
+    Generators generators;
+
+    OptionsParserList optionParser;
+    optionParser.append(Generator::createOptionsParser());
+    optionParser.append(TypeDatabase::instance()->createOptionsParser());
+    ApiExtractor extractor;
+    optionParser.append(extractor.createOptionsParser());
+
     // Pre-defined generator sets.
-    if (generatorSet == u"qtdoc") {
+    if (commonOptions.generatorSet == u"qtdoc") {
         generators = docGenerators();
         if (generators.isEmpty()) {
-            errorPrint(u"Doc strings extractions was not enabled in this shiboken build."_s);
+            errorPrint(u"Doc strings extractions was not enabled in this shiboken build."_s, argV);
             return EXIT_FAILURE;
         }
-    } else if (generatorSet.isEmpty() || generatorSet == u"shiboken") {
+#ifdef DOCSTRINGS_ENABLED
+        optionParser.append(QtDocGenerator::createOptionsParser());
+#endif
+    } else if (commonOptions.generatorSet.isEmpty() || commonOptions.generatorSet == u"shiboken") {
         generators = shibokenGenerators();
+        optionParser.append(ShibokenGenerator::createOptionsParser());
     } else {
-        errorPrint(u"Unknown generator set, try \"shiboken\" or \"qtdoc\"."_s);
+        errorPrint(u"Unknown generator set, try \"shiboken\" or \"qtdoc\"."_s, argV);
         return EXIT_FAILURE;
     }
 
-    ait = args.options.find(u"help"_s);
-    if (ait != args.options.end()) {
-        args.options.erase(ait);
-        printUsage();
-        return EXIT_SUCCESS;
-    }
-
-    ait = args.options.find(diffOption());
-    if (ait != args.options.end()) {
-        args.options.erase(ait);
-        FileOut::setDiff(true);
-    }
-
-    ait = args.options.find(useGlobalHeaderOption());
-    if (ait != args.options.end()) {
-        args.options.erase(ait);
-        ApiExtractor::setUseGlobalHeader(true);
-    }
-
-    ait = args.options.find(dryrunOption());
-    if (ait != args.options.end()) {
-        args.options.erase(ait);
-        FileOut::setDryRun(true);
-    }
-
-    QString licenseComment;
-    ait = args.options.find(u"license-file"_s);
-    if (ait != args.options.end()) {
-        QFile licenseFile(ait.value().toString());
-        args.options.erase(ait);
-        if (licenseFile.open(QIODevice::ReadOnly)) {
-            licenseComment = QString::fromUtf8(licenseFile.readAll());
-        } else {
-            errorPrint(QStringLiteral("Could not open the file \"%1\" containing the license heading: %2").
-                       arg(QDir::toNativeSeparators(licenseFile.fileName()), licenseFile.errorString()));
-            return EXIT_FAILURE;
-        }
-    }
-
-    QString outputDirectory = u"out"_s;
-    ait = args.options.find(u"output-directory"_s);
-    if (ait != args.options.end()) {
-        outputDirectory = ait.value().toString();
-        args.options.erase(ait);
-    }
-
-    if (!QDir(outputDirectory).exists()) {
-        if (!QDir().mkpath(outputDirectory)) {
+    if (!QDir(commonOptions.outputDirectory).exists()) {
+        if (!QDir().mkpath(commonOptions.outputDirectory)) {
             qCWarning(lcShiboken).noquote().nospace()
-                << "Can't create output directory: " << QDir::toNativeSeparators(outputDirectory);
+                << "Can't create output directory: "
+                << QDir::toNativeSeparators(commonOptions.outputDirectory);
             return EXIT_FAILURE;
         }
     }
 
     // Create and set-up API Extractor
-    ApiExtractor extractor;
-    extractor.setLogDirectory(outputDirectory);
-    ait = args.options.find(skipDeprecatedOption());
-    if (ait != args.options.end()) {
-        extractor.setSkipDeprecated(true);
-        args.options.erase(ait);
-    }
-
-    ait = args.options.find(u"silent"_s);
-    if (ait != args.options.end()) {
-        extractor.setSilent(true);
-        args.options.erase(ait);
-    } else {
-        ait = args.options.find(u"debug-level"_s);
-        if (ait != args.options.end()) {
-            const QString value = ait.value().toString();
-            if (!ReportHandler::setDebugLevelFromArg(value)) {
-                errorPrint(u"Invalid debug level: "_s + value);
-                return EXIT_FAILURE;
-            }
-            args.options.erase(ait);
-        }
-    }
-    ait = args.options.find(u"no-suppress-warnings"_s);
-    if (ait != args.options.end()) {
-        args.options.erase(ait);
-        extractor.setSuppressWarnings(false);
-    }
-    ait = args.options.find(apiVersionOption());
-    if (ait != args.options.end()) {
-        const QStringList &versions = ait.value().toStringList();
-        args.options.erase(ait);
-        for (const QString &fullVersion : versions) {
-            QStringList parts = fullVersion.split(u',');
-            QString package;
-            QString version;
-            package = parts.size() == 1 ? u"*"_s : parts.constFirst();
-            version = parts.constLast();
-            if (!extractor.setApiVersion(package, version)) {
-                errorPrint(msgInvalidVersion(package, version));
-                return EXIT_FAILURE;
-            }
-        }
-    }
-
-    ait = args.options.find(dropTypeEntriesOption());
-    if (ait != args.options.end()) {
-        extractor.setDropTypeEntries(ait.value().toStringList());
-        args.options.erase(ait);
-    }
-
-    ait = args.options.find(keywordsOption());
-    if (ait != args.options.end()) {
-        extractor.setTypesystemKeywords(ait.value().toStringList());
-        args.options.erase(ait);
-    }
-
-    ait = args.options.find(typesystemPathOption());
-    if (ait != args.options.end()) {
-        extractor.addTypesystemSearchPath(ait.value().toStringList());
-        args.options.erase(ait);
-    }
-
-    ait = args.options.find(clangOptionsOption());
-    if (ait != args.options.end()) {
-        extractor.setClangOptions(ait.value().toStringList());
-        args.options.erase(ait);
-    }
-
-    ait = args.options.find(compilerOption());
-    if (ait != args.options.end()) {
-        const QString name = ait.value().toString();
-        if (!clang::setCompiler(name)) {
-            errorPrint(u"Invalid value \""_s + name + u"\" passed to --compiler"_s);
+    extractor.setLogDirectory(commonOptions.outputDirectory);
+
+    if (commonOptions.typeSystemFileName.isEmpty() && commonOptions.headers.isEmpty()) {
+        if (options.positionalArguments.size() < 2) {
+            errorPrint(u"Insufficient positional arguments, specify header-file and typesystem-file."_s,
+                       argV);
+            std::cout << '\n';
+            printUsage();
             return EXIT_FAILURE;
         }
-        args.options.erase(ait);
-    }
 
-    ait = args.options.find(printBuiltinTypesOption());
-    const bool printBuiltinTypes = ait != args.options.end();
-    if (printBuiltinTypes)
-        args.options.erase(ait);
-
-    ait = args.options.find(compilerPathOption());
-    if (ait != args.options.end()) {
-        clang::setCompilerPath(ait.value().toString());
-        args.options.erase(ait);
+        commonOptions.typeSystemFileName = options.positionalArguments.takeLast();
+        commonOptions.headers = options.positionalArguments;
     }
 
-    ait = args.options.find(platformOption());
-    if (ait != args.options.end()) {
-        const QString name = ait.value().toString();
-        if (!clang::setPlatform(name)) {
-            errorPrint(u"Invalid value \""_s + name + u"\" passed to --platform"_s);
-            return EXIT_FAILURE;
-        }
-        args.options.erase(ait);
-    }
-
-    parseIncludePathOption(includePathOption(), HeaderType::Standard,
-                           args, extractor);
-    parseIncludePathOption(frameworkIncludePathOption(), HeaderType::Framework,
-                           args, extractor);
-    parseIncludePathOption(systemIncludePathOption(), HeaderType::System,
-                           args, extractor);
-
-    if (args.positionalArguments.size() < 2) {
-        errorPrint(u"Insufficient positional arguments, specify header-file and typesystem-file."_s);
-        std::cout << '\n';
-        printUsage();
-        return EXIT_FAILURE;
-    }
-
-    const QString typeSystemFileName = args.positionalArguments.takeLast();
-    QString messagePrefix = QFileInfo(typeSystemFileName).baseName();
+    QString messagePrefix = QFileInfo(commonOptions.typeSystemFileName).baseName();
     if (messagePrefix.startsWith(u"typesystem_"))
         messagePrefix.remove(0, 11);
     ReportHandler::setPrefix(u'(' + messagePrefix + u')');
 
     QFileInfoList cppFileNames;
-    for (const QString &cppFileName : std::as_const(args.positionalArguments)) {
+    for (const QString &cppFileName : std::as_const(commonOptions.headers)) {
         const QFileInfo cppFileNameFi(cppFileName);
         if (!cppFileNameFi.isFile() && !cppFileNameFi.isSymLink()) {
-            errorPrint(u'"' + cppFileName + u"\" does not exist."_s);
+            errorPrint(u'"' + cppFileName + u"\" does not exist."_s, argV);
             return EXIT_FAILURE;
         }
         cppFileNames.append(cppFileNameFi);
     }
 
-    // Pass option to all generators (Cpp/Header generator have the same options)
-    for (ait = args.options.begin(); ait != args.options.end(); ) {
-        bool found = false;
-        for (const GeneratorPtr &generator : std::as_const(generators))
-            found |= generator->handleOption(ait.key(), ait.value().toString());
-        if (found)
-            ait = args.options.erase(ait);
-        else
-            ++ait;
-    }
-
-    ait = args.options.find(languageLevelOption());
-    if (ait != args.options.end()) {
-        const QByteArray languageLevelBA = ait.value().toString().toLatin1();
-        args.options.erase(ait);
-        const LanguageLevel level = clang::languageLevelFromOption(languageLevelBA.constData());
-        if (level == LanguageLevel::Default) {
-            std::cout << "Invalid argument for language level: \""
-                << languageLevelBA.constData() << "\"\n" << helpHint;
-            return EXIT_FAILURE;
-        }
-        extractor.setLanguageLevel(level);
-    }
-
-    /* Make sure to remove the project file's arguments (if any) and
-     * --project-file, also the arguments of each generator before
-     * checking if there isn't any existing arguments in argsHandler.
-     */
-    args.options.remove(u"project-file"_s);
-    for (auto it = projectFileArguments.options.cbegin(), end = projectFileArguments.options.cend();
-         it != end; ++it) {
-        args.options.remove(it.key());
-    }
+    optionParser.process(&options);
+    optionParser.clear();
 
-    if (!args.options.isEmpty()) {
-        errorPrint(msgLeftOverArguments(args.options));
+    if (!options.boolOptions.isEmpty() || !options.valueOptions.isEmpty()) {
+        errorPrint(msgLeftOverArguments(options.msgUnprocessedOptions(), argV), argV);
         std::cout << helpHint;
         return EXIT_FAILURE;
     }
 
-    if (typeSystemFileName.isEmpty()) {
+    if (commonOptions.typeSystemFileName.isEmpty()) {
         std::cout << "You must specify a Type System file." << std::endl << helpHint;
         return EXIT_FAILURE;
     }
 
     extractor.setCppFileNames(cppFileNames);
-    extractor.setTypeSystem(typeSystemFileName);
+    extractor.setTypeSystem(commonOptions.typeSystemFileName);
 
     ApiExtractorFlags apiExtractorFlags;
     if (generators.constFirst()->usePySideExtensions())
@@ -730,7 +363,7 @@ int shibokenMain(int argc, char *argv[])
     const std::optional<ApiExtractorResult> apiOpt = extractor.run(apiExtractorFlags);
 
     if (!apiOpt.has_value()) {
-        errorPrint(u"Error running ApiExtractor."_s);
+        errorPrint(u"Error running ApiExtractor."_s, argV);
         return EXIT_FAILURE;
     }
 
@@ -743,35 +376,59 @@ int shibokenMain(int argc, char *argv[])
             << "\n\nType datase:\n" << *TypeDatabase::instance();
     }
 
-    if (printBuiltinTypes)
+    if (commonOptions.printBuiltinTypes)
         TypeDatabase::instance()->formatBuiltinTypes(qInfo());
 
     for (const GeneratorPtr &g : std::as_const(generators)) {
-        g->setOutputDirectory(outputDirectory);
-        g->setLicenseComment(licenseComment);
-        ReportHandler::startProgress(QByteArray("Running ") + g->name() + "...");
+        g->setOutputDirectory(commonOptions.outputDirectory);
+        g->setLicenseComment(commonOptions.licenseComment);
+        ReportHandler::startProgress("Ran "_ba + g->name() + '.');
         const bool ok = g->setup(apiOpt.value()) && g->generate();
         ReportHandler::endProgress();
          if (!ok) {
              errorPrint(u"Error running generator: "_s
-                        + QLatin1StringView(g->name()) + u'.');
+                        + QLatin1StringView(g->name()) + u'.', argV);
              return EXIT_FAILURE;
          }
     }
 
+    if (commonOptions.logUnmatched)
+        TypeDatabase::instance()->logUnmatched();
+
     const QByteArray doneMessage = ReportHandler::doneMessage();
     std::cout << doneMessage.constData() << std::endl;
 
     return EXIT_SUCCESS;
 }
 
+#ifndef Q_OS_WIN
+
+static inline QString argvToString(const char *arg)
+{
+    return QString::fromLocal8Bit(arg);
+}
+
 int main(int argc, char *argv[])
+#else
+
+static inline QString argvToString(const  wchar_t *arg)
+{
+    return QString::fromWCharArray(arg);
+}
+
+int wmain(int argc, wchar_t *argv[])
+#endif
 {
     int ex = EXIT_SUCCESS;
+
+    QStringList argV;
+    argV.reserve(argc - 1);
+    std::transform(argv + 1, argv + argc, std::back_inserter(argV), argvToString);
+
     try {
-        ex = shibokenMain(argc, argv);
+        ex = shibokenMain(argV);
     }  catch (const std::exception &e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << appName << " error: " << e.what() << std::endl;
         ex = EXIT_FAILURE;
     }
     return ex;
diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
index cf16efaa0..1634a7e83 100644
--- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
+++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
@@ -15,6 +15,7 @@
 #include <abstractmetafield.h>
 #include <abstractmetafunction.h>
 #include <abstractmetalang.h>
+#include "abstractmetalang_helpers.h"
 #include <fileout.h>
 #include <messages.h>
 #include <modifications.h>
@@ -25,6 +26,8 @@
 #include <functiontypeentry.h>
 #include <enumtypeentry.h>
 #include <complextypeentry.h>
+#include <flagstypeentry.h>
+#include <primitivetypeentry.h>
 #include <qtdocparser.h>
 #include <doxygenparser.h>
 
@@ -36,12 +39,36 @@
 #include <QtCore/QJsonArray>
 #include <QtCore/QJsonDocument>
 #include <QtCore/QJsonObject>
+#include <QtCore/QSet>
 
 #include <algorithm>
 #include <limits>
 
 using namespace Qt::StringLiterals;
 
+static inline QString classScope(const AbstractMetaClassCPtr &metaClass)
+{
+    return metaClass->fullName();
+}
+
+struct DocPackage
+{
+    QStringList classPages;
+    QStringList decoratorPages;
+    AbstractMetaFunctionCList globalFunctions;
+    AbstractMetaEnumList globalEnums;
+};
+
+struct DocGeneratorOptions
+{
+    QtXmlToSphinxParameters parameters;
+    QString extraSectionDir;
+    QString additionalDocumentationList;
+    QString inheritanceFile;
+    bool doxygen = false;
+    bool inheritanceDiagram = true;
+};
+
 struct GeneratorDocumentation
 {
     struct Property
@@ -55,8 +82,7 @@ struct GeneratorDocumentation
         AbstractMetaFunctionCPtr notify;
     };
 
-    AbstractMetaFunctionCList constructors;
-    AbstractMetaFunctionCList allFunctions; // Except constructors
+    AbstractMetaFunctionCList allFunctions;
     AbstractMetaFunctionCList tocNormalFunctions; // Index lists
     AbstractMetaFunctionCList tocVirtuals;
     AbstractMetaFunctionCList tocSignalFunctions;
@@ -72,19 +98,18 @@ static bool operator<(const GeneratorDocumentation::Property &lhs,
     return lhs.name < rhs.name;
 }
 
-static QString propertyRefTarget(const AbstractMetaClass *cppClass, const QString &name)
+static QString propertyRefTarget(const QString &name)
 {
-    QString result = cppClass->fullName() +  u'.' + name;
-    result.replace(u"::"_s, u"."_s);
+    QString result = name;
     // For sphinx referencing, disambiguate the target from the getter name
-    // by inserting an invisible "Hangul choseong filler" character.
-    result.insert(1, QChar(0x115F));
+    // by appending an invisible "Hangul choseong filler" character.
+    result.append(QChar(0x115F));
     return result;
 }
 
-static inline QString additionalDocumentationOption() { return QStringLiteral("additional-documentation"); }
+constexpr auto additionalDocumentationOption = "additional-documentation"_L1;
 
-static inline QString none() { return QStringLiteral("None"); }
+constexpr auto none = "None"_L1;
 
 static bool shouldSkip(const AbstractMetaFunctionCPtr &func)
 {
@@ -121,7 +146,14 @@ static bool shouldSkip(const AbstractMetaFunctionCPtr &func)
 
 static bool functionSort(const AbstractMetaFunctionCPtr &func1, const AbstractMetaFunctionCPtr &func2)
 {
-    return func1->name() < func2->name();
+    const bool ctor1 = func1->isConstructor();
+    if (ctor1 != func2->isConstructor())
+        return ctor1;
+    const QString &name1 = func1->name();
+    const QString &name2 = func2->name();
+    if (name1 != name2)
+        return name1 < name2;
+    return func1->arguments().size() < func2->arguments().size();
 }
 
 static inline QVersionNumber versionOf(const TypeEntryCPtr &te)
@@ -131,82 +163,144 @@ static inline QVersionNumber versionOf(const TypeEntryCPtr &te)
         if (!version.isNull() && version > QVersionNumber(0, 0))
             return version;
     }
-    return QVersionNumber();
+    return {};
 }
 
-// Format a documentation reference (meth/attr): ":meth:`name<target>`"
-// We do not use the short form ":meth:`~target`" since that adds parentheses ()
-// for functions where we list the parameters instead.
 struct docRef
 {
-    explicit docRef(const char *kind, const QString &name, const AbstractMetaClass *cppClass) :
-        m_kind(kind), m_name(name), m_cppClass(cppClass) {}
+    explicit docRef(const char *kind, QAnyStringView name) :
+        m_kind(kind), m_name(name) {}
 
     const char *m_kind;
-    const QString &m_name;
-    const AbstractMetaClass *m_cppClass;
+    QAnyStringView m_name;
 };
 
 static TextStream &operator<<(TextStream &s, const docRef &dr)
 {
-    QString className = dr.m_cppClass->fullName();
-    className.replace(u"::"_s, u"."_s);
-    s << ':' << dr.m_kind << ":`" << dr.m_name << '<';
-    if (!dr.m_name.startsWith(className))
-        s << className << '.';
-    s << dr.m_name << ">`";
+    s << ':' << dr.m_kind << ":`" << dr.m_name << '`';
     return s;
 }
 
+static QString fileNameToTocEntry(const QString &fileName)
+{
+    constexpr auto rstSuffix = ".rst"_L1;
+
+    QString result = fileName;
+    if (result.endsWith(rstSuffix))
+        result.chop(rstSuffix.size()); // Remove the .rst extension
+    // skip namespace if necessary
+    auto lastDot = result.lastIndexOf(u'.');
+    if (lastDot != -1)
+        result.remove(0, lastDot + 1);
+    return result;
+}
+
+static void readExtraDoc(const QFileInfo &fi,
+                         const QString &moduleName,
+                         const QString &outputDir,
+                         DocPackage *docPackage, QStringList *extraTocEntries)
+{
+    // Strip to "Property.rst" in output directory
+    const QString newFileName = fi.fileName().mid(moduleName.size() + 1);
+    QFile sourceFile(fi.absoluteFilePath());
+    if (!sourceFile.open(QIODevice::ReadOnly|QIODevice::Text)) {
+        qCWarning(lcShibokenDoc, "%s", qPrintable(msgCannotOpenForReading(sourceFile)));
+        return;
+    }
+    const QByteArray contents = sourceFile.readAll();
+    sourceFile.close();
+    QFile targetFile(outputDir + u'/' + newFileName);
+    if (!targetFile.open(QIODevice::WriteOnly|QIODevice::Text)) {
+        qCWarning(lcShibokenDoc, "%s", qPrintable(msgCannotOpenForWriting(targetFile)));
+        return;
+    }
+    targetFile.write(contents);
+    if (contents.contains("decorator::"))
+        docPackage->decoratorPages.append(newFileName);
+    else
+        docPackage->classPages.append(newFileName);
+    extraTocEntries->append(fileNameToTocEntry(newFileName));
+}
+
 // Format a short documentation reference (automatically dropping the prefix
 // by using '~'), usable for property/attributes ("attr").
 struct shortDocRef
 {
-    explicit shortDocRef(const char *kind, const QString &target) :
-        m_kind(kind), m_target(target) {}
+    explicit shortDocRef(const char *kind, QAnyStringView name) :
+        m_kind(kind), m_name(name) {}
 
     const char *m_kind;
-    const QString &m_target;
+    QAnyStringView m_name;
 };
 
 static TextStream &operator<<(TextStream &s, const shortDocRef &sdr)
 {
-    s << ':' << sdr.m_kind << ":`~" << sdr.m_target << '`';
+    s << ':' << sdr.m_kind << ":`~" << sdr.m_name << '`';
     return s;
 }
 
 struct functionRef : public docRef
 {
-    explicit functionRef(const QString &name, const AbstractMetaClass *cppClass) :
-        docRef("meth", name, cppClass) {}
+    explicit functionRef(QAnyStringView name) : docRef("meth", name) {}
 };
 
-struct functionTocEntry // Format a TOC entry for a function
+struct classRef : public shortDocRef
 {
-    explicit functionTocEntry(const AbstractMetaFunctionCPtr& func,
-                              const AbstractMetaClass *cppClass) :
-        m_func(func), m_cppClass(cppClass) {}
+    explicit classRef(QAnyStringView name) : shortDocRef("class", name) {}
+};
 
-    AbstractMetaFunctionCPtr m_func;
-    const AbstractMetaClass *m_cppClass;
+struct propRef : public shortDocRef // Attribute/property (short) reference
+{
+    explicit propRef(const QString &target) :
+        shortDocRef("attr", target) {}
 };
 
-static TextStream &operator<<(TextStream &s, const functionTocEntry &ft)
+struct headline
 {
-    s << functionRef(QtDocGenerator::getFuncName(ft.m_func), ft.m_cppClass)
-        << ' ' << QtDocGenerator::formatArgs(ft.m_func);
+    explicit headline(QAnyStringView title, char underLineChar = '-') :
+        m_title(title), m_underLineChar(underLineChar) {}
+
+    QAnyStringView m_title;
+    char m_underLineChar;
+};
+
+static TextStream &operator<<(TextStream &s, const headline &h)
+{
+    s << h.m_title << '\n' << Pad(h.m_underLineChar, h.m_title.size()) << "\n\n";
     return s;
 }
 
-struct propRef : public shortDocRef // Attribute/property (short) reference
+struct pyClass
 {
-    explicit propRef(const QString &target) :
-        shortDocRef("attr", target) {}
+    explicit pyClass(QAnyStringView name) : m_name(name)  {}
+
+    QAnyStringView m_name;
+};
+
+static TextStream &operator<<(TextStream &s, pyClass c)
+{
+    s << ".. py:class:: " << c.m_name << "\n\n";
+    return s;
+}
+
+struct currentModule
+{
+    explicit currentModule(QAnyStringView module) : m_module(module)  {}
+
+    QAnyStringView m_module;
 };
 
+static TextStream &operator<<(TextStream &s, const currentModule &m)
+{
+    s << ".. currentmodule:: " << m.m_module << "\n\n\n";
+    return s;
+}
+
+DocGeneratorOptions QtDocGenerator::m_options;
+
 QtDocGenerator::QtDocGenerator()
 {
-    m_parameters.snippetComparison =
+    m_options.parameters.snippetComparison =
         ReportHandler::debugLevel() >= ReportHandler::FullDebug;
 }
 
@@ -231,28 +325,23 @@ QString QtDocGenerator::fileNameForContext(const GeneratorContext &context) cons
 }
 
 void QtDocGenerator::writeFormattedBriefText(TextStream &s, const Documentation &doc,
-                                             const AbstractMetaClass *metaclass) const
+                                             const QString &scope) const
 {
-    writeFormattedText(s, doc.brief(), doc.format(), metaclass);
+    writeFormattedText(s, doc.brief(), doc.format(), scope);
 }
 
 void QtDocGenerator::writeFormattedDetailedText(TextStream &s, const Documentation &doc,
-                                                const AbstractMetaClass *metaclass) const
+                                                const QString &scope) const
 {
-    writeFormattedText(s, doc.detailed(), doc.format(), metaclass);
+    writeFormattedText(s, doc.detailed(), doc.format(), scope);
 }
 
 void QtDocGenerator::writeFormattedText(TextStream &s, const QString &doc,
                                         Documentation::Format format,
-                                        const AbstractMetaClass *metaClass) const
+                                        const QString &scope) const
 {
-    QString metaClassName;
-
-    if (metaClass)
-        metaClassName = metaClass->fullName();
-
     if (format == Documentation::Native) {
-        QtXmlToSphinx x(this, m_parameters, doc, metaClassName);
+        QtXmlToSphinx x(this, m_options.parameters, doc, scope);
         s << x;
     } else {
         const auto lines = QStringView{doc}.split(u'\n');
@@ -276,50 +365,71 @@ void QtDocGenerator::writeFormattedText(TextStream &s, const QString &doc,
     s << '\n';
 }
 
-static void writeInheritedByList(TextStream &s, const AbstractMetaClass *metaClass,
+static void writeInheritanceList(TextStream &s, const AbstractMetaClassCList& classes,
+                                 const char *label)
+{
+    s << "**" << label << ":** ";
+    for (qsizetype i = 0, size = classes.size(); i < size; ++i) {
+        if (i > 0)
+            s << ", ";
+        s << classRef(classes.at(i)->fullName());
+    }
+    s << "\n\n";
+}
+
+static void writeInheritedByList(TextStream &s, const AbstractMetaClassCPtr &metaClass,
                                  const AbstractMetaClassCList& allClasses)
 {
     AbstractMetaClassCList res;
-    for (auto c : allClasses) {
-        if (c != metaClass && c->inheritsFrom(metaClass))
+    for (const auto &c : allClasses) {
+        if (c != metaClass && inheritsFrom(c, metaClass))
             res << c;
     }
 
-    if (res.isEmpty())
-        return;
+    if (!res.isEmpty())
+        writeInheritanceList(s, res, "Inherited by");
+}
+
+static void writeInheritedFromList(TextStream &s, const AbstractMetaClassCPtr &metaClass)
+{
+    AbstractMetaClassCList res;
 
-    s << "**Inherited by:** ";
-    QStringList classes;
-    for (auto c : std::as_const(res))
-        classes << u":ref:`"_s + c->name() + u'`';
-    s << classes.join(u", "_s) << "\n\n";
+    recurseClassHierarchy(metaClass, [&res, metaClass](const AbstractMetaClassCPtr &c) {
+        if (c.get() != metaClass.get())
+            res.append(c);
+        return false;
+    });
+
+    if (!res.isEmpty())
+        writeInheritanceList(s, res, "Inherits from");
 }
 
 void QtDocGenerator::generateClass(TextStream &s, const GeneratorContext &classContext)
 {
-    const AbstractMetaClass *metaClass = classContext.metaClass();
+    AbstractMetaClassCPtr metaClass = classContext.metaClass();
     qCDebug(lcShibokenDoc).noquote().nospace() << "Generating Documentation for " << metaClass->fullName();
 
-    m_packages[metaClass->package()] << fileNameForContext(classContext);
+    m_packages[metaClass->package()].classPages << fileNameForContext(classContext);
 
     m_docParser->setPackageName(metaClass->package());
-    m_docParser->fillDocumentation(const_cast<AbstractMetaClass*>(metaClass));
-
-    QString className = metaClass->name();
-    s << ".. _" << className << ":" << "\n\n";
-    s << ".. currentmodule:: " << metaClass->package() << "\n\n\n";
+    m_docParser->fillDocumentation(std::const_pointer_cast<AbstractMetaClass>(metaClass));
 
-    s << className << '\n';
-    s << Pad('*', className.size()) << "\n\n";
+    s << currentModule(metaClass->package()) << pyClass(metaClass->name());
+    Indentation indent(s);
 
     auto documentation = metaClass->documentation();
+    const QString scope = classScope(metaClass);
     if (documentation.hasBrief())
-        writeFormattedBriefText(s, documentation, metaClass);
-
-    s << ".. inheritance-diagram:: " << metaClass->fullName()<< '\n'
-      << "    :parts: 2\n\n";
-    // TODO: This would be a parameter in the future...
+        writeFormattedBriefText(s, documentation, scope);
 
+    if (!metaClass->baseClasses().isEmpty()) {
+        if (m_options.inheritanceDiagram) {
+            s << ".. inheritance-diagram:: " << metaClass->fullName()<< '\n'
+              << "    :parts: 2\n\n";
+        } else {
+            writeInheritedFromList(s, metaClass);
+        }
+    }
 
     writeInheritedByList(s, metaClass, api().classes());
 
@@ -332,73 +442,68 @@ void QtDocGenerator::generateClass(TextStream &s, const GeneratorContext &classC
     const GeneratorDocumentation doc = generatorDocumentation(metaClass);
 
     if (!doc.allFunctions.isEmpty() || !doc.properties.isEmpty()) {
-        s << "\nSynopsis\n--------\n\n";
-        writePropertyToc(s, doc, metaClass);
-        writeFunctionToc(s, u"Functions"_s, metaClass, doc.tocNormalFunctions);
-        writeFunctionToc(s, u"Virtual functions"_s, metaClass, doc.tocVirtuals);
-        writeFunctionToc(s, u"Slots"_s, metaClass, doc.tocSlotFunctions);
-        writeFunctionToc(s, u"Signals"_s, metaClass, doc.tocSignalFunctions);
-        writeFunctionToc(s, u"Static functions"_s, metaClass, doc.tocStaticFunctions);
+        s << '\n' << headline("Synopsis");
+        writePropertyToc(s, doc);
+        writeFunctionToc(s, u"Methods"_s, doc.tocNormalFunctions);
+        writeFunctionToc(s, u"Virtual methods"_s, doc.tocVirtuals);
+        writeFunctionToc(s, u"Slots"_s, doc.tocSlotFunctions);
+        writeFunctionToc(s, u"Signals"_s, doc.tocSignalFunctions);
+        writeFunctionToc(s, u"Static functions"_s, doc.tocStaticFunctions);
     }
 
-    s << "\nDetailed Description\n"
-           "--------------------\n\n"
-        << ".. _More:\n";
+    s << "\n.. note::\n"
+         "    This documentation may contain snippets that were automatically\n"
+         "    translated from C++ to Python. We always welcome contributions\n"
+         "    to the snippet translation. If you see an issue with the\n"
+         "    translation, you can also let us know by creating a ticket on\n"
+         "    https:/bugreports.qt.io/projects/PYSIDE\n\n";
 
-    writeInjectDocumentation(s, TypeSystem::DocModificationPrepend, metaClass, nullptr);
-    if (!writeInjectDocumentation(s, TypeSystem::DocModificationReplace, metaClass, nullptr))
-        writeFormattedDetailedText(s, documentation, metaClass);
+    s << '\n' << headline("Detailed Description") << ".. _More:\n";
 
-    if (!metaClass->isNamespace())
-        writeConstructors(s, metaClass, doc.constructors);
+    writeInjectDocumentation(s, TypeSystem::DocModificationPrepend, metaClass);
+    if (!writeInjectDocumentation(s, TypeSystem::DocModificationReplace, metaClass))
+        writeFormattedDetailedText(s, documentation, scope);
+    writeInjectDocumentation(s, TypeSystem::DocModificationAppend, metaClass);
+
+    writeEnums(s, metaClass->enums(), scope);
 
     if (!doc.properties.isEmpty())
         writeProperties(s, doc, metaClass);
 
-    writeEnums(s, metaClass);
     if (!metaClass->isNamespace())
         writeFields(s, metaClass);
 
-    QString lastName;
-    for (const auto &func : std::as_const(doc.allFunctions)) {
-        const bool indexed = func->name() != lastName;
-        lastName = func->name();
-        s << (func->isStatic() ? ".. py:staticmethod:: " : ".. py:method:: ");
-        writeFunction(s, metaClass, func, indexed);
-    }
-
-    writeInjectDocumentation(s, TypeSystem::DocModificationAppend, metaClass, nullptr);
+    writeFunctions(s, doc.allFunctions, metaClass, scope);
 }
 
 void QtDocGenerator::writeFunctionToc(TextStream &s, const QString &title,
-                                      const AbstractMetaClass *cppClass,
                                       const AbstractMetaFunctionCList &functions)
 {
     if (!functions.isEmpty()) {
-        s << title << '\n'
-          << Pad('^', title.size()) << '\n';
-
-        s << ".. container:: function_list\n\n" << indent;
-        for (const auto &func : functions)
-            s << "* def " << functionTocEntry(func, cppClass) << '\n';
+        s << headline(title, '^')
+          << ".. container:: function_list\n\n" << indent;
+        // Functions are sorted by the Metabuilder; erase overloads
+        QStringList toc;
+        toc.reserve(functions.size());
+        std::transform(functions.cbegin(), functions.end(),
+                       std::back_inserter(toc), getFuncName);
+        toc.erase(std::unique(toc.begin(), toc.end()), toc.end());
+        for (const auto &func : toc)
+            s << "* def " << functionRef(func) << '\n';
         s << outdent << "\n\n";
     }
 }
 
 void QtDocGenerator::writePropertyToc(TextStream &s,
-                                      const GeneratorDocumentation &doc,
-                                      const AbstractMetaClass *cppClass)
+                                      const GeneratorDocumentation &doc)
 {
     if (doc.properties.isEmpty())
         return;
 
-    const QString title = u"Properties"_s;
-    s << title << '\n'
-      << Pad('^', title.size()) << '\n';
-
-    s << ".. container:: function_list\n\n" << indent;
+    s << headline("Properties", '^')
+        << ".. container:: function_list\n\n" << indent;
     for (const auto &prop : doc.properties) {
-        s << "* " << propRef(propertyRefTarget(cppClass, prop.name));
+        s << "* " << propRef(propertyRefTarget(prop.name));
         if (prop.documentation.hasBrief())
             s << " - " << prop.documentation.brief();
         s << '\n';
@@ -408,38 +513,39 @@ void QtDocGenerator::writePropertyToc(TextStream &s,
 
 void QtDocGenerator::writeProperties(TextStream &s,
                                      const GeneratorDocumentation &doc,
-                                     const AbstractMetaClass *cppClass) const
+                                     const AbstractMetaClassCPtr &cppClass) const
 {
     s << "\n.. note:: Properties can be used directly when "
         << "``from __feature__ import true_property`` is used or via accessor "
         << "functions otherwise.\n\n";
 
+    const QString scope = classScope(cppClass);
     for (const auto &prop : doc.properties) {
         const QString type = translateToPythonType(prop.type, cppClass, /* createRef */ false);
-        s <<  ".. py:property:: " << propertyRefTarget(cppClass, prop.name)
+        s <<  ".. py:property:: " << propertyRefTarget(prop.name)
             << "\n   :type: " << type << "\n\n\n";
         if (!prop.documentation.isEmpty())
-            writeFormattedText(s, prop.documentation.detailed(), Documentation::Native, cppClass);
+            writeFormattedText(s, prop.documentation.detailed(), Documentation::Native, scope);
         s << "**Access functions:**\n";
-        if (!prop.getter.isNull())
-            s << " * " << functionTocEntry(prop.getter, cppClass) << '\n';
-        if (!prop.setter.isNull())
-            s << " * " << functionTocEntry(prop.setter, cppClass) << '\n';
-        if (!prop.reset.isNull())
-            s << " * " << functionTocEntry(prop.reset, cppClass) << '\n';
-        if (!prop.notify.isNull())
-            s << " * Signal " << functionTocEntry(prop.notify, cppClass) << '\n';
+        if (prop.getter)
+            s << " * " << functionRef(prop.getter->name()) << '\n';
+        if (prop.setter)
+            s << " * " << functionRef(prop.setter->name()) << '\n';
+        if (prop.reset)
+            s << " * " << functionRef(prop.reset->name()) << '\n';
+        if (prop.notify)
+            s << " * Signal " << functionRef(prop.notify->name()) << '\n';
         s << '\n';
     }
 }
 
-void QtDocGenerator::writeEnums(TextStream &s, const AbstractMetaClass *cppClass) const
+void QtDocGenerator::writeEnums(TextStream &s, const AbstractMetaEnumList &enums,
+                                const QString &scope) const
 {
-    static const QString section_title = u".. attribute:: "_s;
-
-    for (const AbstractMetaEnum &en : cppClass->enums()) {
-        s << section_title << cppClass->fullName() << '.' << en.name() << "\n\n";
-        writeFormattedDetailedText(s, en.documentation(), cppClass);
+    for (const AbstractMetaEnum &en : enums) {
+        s << pyClass(en.name());
+        Indentation indent(s);
+        writeFormattedDetailedText(s, en.documentation(), scope);
         const auto version = versionOf(en.typeEntry());
         if (!version.isNull())
             s << rstVersionAdded(version);
@@ -447,66 +553,17 @@ void QtDocGenerator::writeEnums(TextStream &s, const AbstractMetaClass *cppClass
 
 }
 
-void QtDocGenerator::writeFields(TextStream &s, const AbstractMetaClass *cppClass) const
+void QtDocGenerator::writeFields(TextStream &s, const AbstractMetaClassCPtr &cppClass) const
 {
-    static const QString section_title = u".. attribute:: "_s;
+    constexpr auto section_title = ".. attribute:: "_L1;
 
+    const QString scope = classScope(cppClass);
     for (const AbstractMetaField &field : cppClass->fields()) {
         s << section_title << cppClass->fullName() << "." << field.name() << "\n\n";
-        writeFormattedDetailedText(s, field.documentation(), cppClass);
+        writeFormattedDetailedText(s, field.documentation(), scope);
     }
 }
 
-void QtDocGenerator::writeConstructors(TextStream &s, const AbstractMetaClass *cppClass,
-                                       const AbstractMetaFunctionCList &constructors) const
-{
-    static const QString sectionTitle = u".. class:: "_s;
-
-    bool first = true;
-    QHash<QString, AbstractMetaArgument> arg_map;
-
-    if (constructors.isEmpty()) {
-        s << sectionTitle << cppClass->fullName();
-    } else {
-        QByteArray pad;
-        for (const auto &func : constructors) {
-            s << pad;
-            if (first) {
-                first = false;
-                s << sectionTitle;
-                pad = QByteArray(sectionTitle.size(), ' ');
-            }
-            s << functionSignature(cppClass, func) << "\n\n";
-
-            const auto version = versionOf(func->typeEntry());
-            if (!version.isNull())
-                s << pad << rstVersionAdded(version);
-            if (func->isDeprecated())
-                s << pad << rstDeprecationNote("constructor");
-
-            const AbstractMetaArgumentList &arguments = func->arguments();
-            for (const AbstractMetaArgument &arg : arguments) {
-                if (!arg_map.contains(arg.name())) {
-                    arg_map.insert(arg.name(), arg);
-                }
-            }
-        }
-    }
-
-    s << '\n';
-
-    for (auto it = arg_map.cbegin(), end = arg_map.cend(); it != end; ++it) {
-        s.indent(2);
-        writeParameterType(s, cppClass, it.value());
-        s.outdent(2);
-    }
-
-    s << '\n';
-
-    for (const auto &func : constructors)
-        writeFormattedDetailedText(s, func->documentation(), cppClass);
-}
-
 QString QtDocGenerator::formatArgs(const AbstractMetaFunctionCPtr &func)
 {
     QString ret = u"("_s;
@@ -538,13 +595,13 @@ QString QtDocGenerator::formatArgs(const AbstractMetaFunctionCPtr &func)
                        || defValue.startsWith(u"QList")) {
                 defValue = u"list()"_s;
             } else if (defValue == u"QVariant()") {
-                defValue = none();
+                defValue = none;
             } else {
                 defValue.replace(u"::"_s, u"."_s);
                 if (defValue == u"nullptr")
-                    defValue = none();
+                    defValue = none;
                 else if (defValue == u"0" && arg.type().isObject())
-                    defValue = none();
+                    defValue = none;
             }
             ret += u'=' + defValue;
         }
@@ -612,25 +669,21 @@ void QtDocGenerator::writeDocSnips(TextStream &s,
     }
 }
 
-bool QtDocGenerator::writeInjectDocumentation(TextStream &s,
-                                            TypeSystem::DocModificationMode mode,
-                                            const AbstractMetaClass *cppClass,
-                                            const AbstractMetaFunctionCPtr &func)
+bool QtDocGenerator::writeDocModifications(TextStream &s,
+                                           const DocModificationList &mods,
+                                           TypeSystem::DocModificationMode mode,
+                                           const QString &scope) const
 {
-    Indentation indentation(s);
     bool didSomething = false;
-
-    const DocModificationList mods = DocParser::getDocModifications(cppClass, func);
-
     for (const DocModification &mod : mods) {
         if (mod.mode() == mode) {
             switch (mod.format()) {
             case TypeSystem::NativeCode:
-                writeFormattedText(s, mod.code(), Documentation::Native, cppClass);
+                writeFormattedText(s, mod.code(), Documentation::Native, scope);
                 didSomething = true;
                 break;
             case TypeSystem::TargetLangCode:
-                writeFormattedText(s, mod.code(), Documentation::Target, cppClass);
+                writeFormattedText(s, mod.code(), Documentation::Target, scope);
                 didSomething = true;
                 break;
             default:
@@ -638,67 +691,105 @@ bool QtDocGenerator::writeInjectDocumentation(TextStream &s,
             }
         }
     }
+    return didSomething;
+}
 
+bool QtDocGenerator::writeInjectDocumentation(TextStream &s,
+                                              TypeSystem::DocModificationMode mode,
+                                              const AbstractMetaClassCPtr &cppClass) const
+{
+    const bool didSomething =
+        writeDocModifications(s, DocParser::getDocModifications(cppClass),
+                              mode, classScope(cppClass));
     s << '\n';
 
     // FIXME PYSIDE-7: Deprecate the use of doc string on glue code.
     //       This is pre "add-function" and "inject-documentation" tags.
     const TypeSystem::CodeSnipPosition pos = mode == TypeSystem::DocModificationPrepend
         ? TypeSystem::CodeSnipPositionBeginning : TypeSystem::CodeSnipPositionEnd;
-    if (func)
-        writeDocSnips(s, func->injectedCodeSnips(), pos, TypeSystem::TargetLangCode);
-    else
-        writeDocSnips(s, cppClass->typeEntry()->codeSnips(), pos, TypeSystem::TargetLangCode);
+    writeDocSnips(s, cppClass->typeEntry()->codeSnips(), pos, TypeSystem::TargetLangCode);
     return didSomething;
 }
 
-QString QtDocGenerator::functionSignature(const AbstractMetaClass *cppClass,
-                                          const AbstractMetaFunctionCPtr &func)
+bool QtDocGenerator::writeInjectDocumentation(TextStream &s,
+                                              TypeSystem::DocModificationMode mode,
+                                              const DocModificationList &modifications,
+                                              const AbstractMetaFunctionCPtr &func,
+                                              const QString &scope) const
 {
-    QString funcName = cppClass->fullName();
-    if (!func->isConstructor())
-        funcName += u'.' + getFuncName(func);
+    const bool didSomething = writeDocModifications(s, modifications, mode, scope);
+    s << '\n';
 
-    return funcName + formatArgs(func);
+    // FIXME PYSIDE-7: Deprecate the use of doc string on glue code.
+    //       This is pre "add-function" and "inject-documentation" tags.
+    const TypeSystem::CodeSnipPosition pos = mode == TypeSystem::DocModificationPrepend
+        ? TypeSystem::CodeSnipPositionBeginning : TypeSystem::CodeSnipPositionEnd;
+    writeDocSnips(s, func->injectedCodeSnips(), pos, TypeSystem::TargetLangCode);
+    return didSomething;
+}
+
+static QString inline toRef(const QString &t)
+{
+    return ":class:`~"_L1 + t + u'`';
 }
 
 QString QtDocGenerator::translateToPythonType(const AbstractMetaType &type,
-                                              const AbstractMetaClass *cppClass,
+                                              const AbstractMetaClassCPtr &cppClass,
                                               bool createRef) const
 {
     static const QStringList nativeTypes =
-        {boolT(), floatT(), intT(), pyObjectT(), pyStrT()};
+        {boolT, floatT, intT, pyObjectT, pyStrT};
 
-    const QString name = type.name();
+    QString name = type.name();
     if (nativeTypes.contains(name))
         return name;
 
-    static const QMap<QString, QString> typeMap = {
-        { cPyObjectT(), pyObjectT() },
-        { qStringT(), pyStrT() },
-        { u"uchar"_s, pyStrT() },
+    if (type.typeUsagePattern() == AbstractMetaType::PrimitivePattern) {
+        const auto &basicName = basicReferencedTypeEntry(type.typeEntry())->name();
+        if (AbstractMetaType::cppSignedIntTypes().contains(basicName)
+            || AbstractMetaType::cppUnsignedIntTypes().contains(basicName)) {
+            return intT;
+        }
+        if (AbstractMetaType::cppFloatTypes().contains(basicName))
+            return floatT;
+    }
+
+    static const QSet<QString> stringTypes = {
+        u"uchar"_s, u"std::string"_s, u"std::wstring"_s,
+        u"std::stringview"_s, u"std::wstringview"_s,
+        qStringT, u"QStringView"_s, u"QAnyStringView"_s, u"QUtf8StringView"_s
+    };
+    if (stringTypes.contains(name))
+        return pyStrT;
+
+    static const QHash<QString, QString> typeMap = {
+        { cPyObjectT, pyObjectT },
         { u"QStringList"_s, u"list of strings"_s },
-        { qVariantT(), pyObjectT() },
-        { u"quint32"_s, intT() },
-        { u"uint32_t"_s, intT() },
-        { u"quint64"_s, intT() },
-        { u"qint64"_s, intT() },
-        { u"size_t"_s, intT() },
-        { u"int64_t"_s, intT() },
-        { u"qreal"_s, floatT() }
+        { qVariantT, pyObjectT }
     };
-    const auto found = typeMap.find(name);
-    if (found != typeMap.end())
+    const auto found = typeMap.constFind(name);
+    if (found != typeMap.cend())
         return found.value();
 
-    QString strType;
-    if (type.isConstant() && name == u"char" && type.indirections() == 1) {
-        strType = u"str"_s;
-    } else if (name.startsWith(unsignedShortT())) {
-        strType = intT();
-    } else if (name.startsWith(unsignedT())) { // uint and ulong
-        strType = intT();
-    } else if (type.isContainer()) {
+    if (type.isFlags()) {
+        const auto fte = std::static_pointer_cast<const FlagsTypeEntry>(type.typeEntry());
+        auto enumTypeEntry = fte->originator();
+        auto enumName = enumTypeEntry->targetLangName();
+        if (createRef)
+            enumName.prepend(enumTypeEntry->targetLangPackage() + u'.');
+        return "Combination of "_L1 + (createRef ? toRef(enumName) : enumName);
+    } else if (type.isEnum()) {
+        auto enumTypeEntry = std::static_pointer_cast<const EnumTypeEntry>(type.typeEntry());
+        auto enumName = enumTypeEntry->targetLangName();
+        if (createRef)
+            enumName.prepend(enumTypeEntry->targetLangPackage() + u'.');
+        return createRef ? toRef(enumName) : enumName;
+    }
+
+    if (type.isConstant() && name == "char"_L1 && type.indirections() == 1)
+        return "str"_L1;
+
+    if (type.isContainer()) {
         QString strType = translateType(type, cppClass, Options(ExcludeConst) | ExcludeReference);
         strType.remove(u'*');
         strType.remove(u'>');
@@ -714,19 +805,19 @@ QString QtDocGenerator::translateToPythonType(const AbstractMetaType &type,
             strType = QString::fromLatin1("Dictionary with keys of type %1 and values of type %2.")
                                          .arg(types[0], types[1]);
         }
-    } else {
-        auto k = AbstractMetaClass::findClass(api().classes(), type.typeEntry());
-        strType = k ? k->fullName() : type.name();
-        if (createRef) {
-            strType.prepend(u":any:`"_s);
-            strType.append(u'`');
-        }
+        return strType;
     }
-    return strType;
+
+    if (auto k = AbstractMetaClass::findClass(api().classes(), type.typeEntry()))
+        return createRef ? toRef(k->fullName()) : k->name();
+
+    return createRef ? toRef(name) : name;
 }
 
 QString QtDocGenerator::getFuncName(const AbstractMetaFunctionCPtr &cppFunc)
 {
+    if (cppFunc->isConstructor())
+        return "__init__"_L1;
     QString result = cppFunc->name();
     if (cppFunc->isOperatorOverload()) {
         const QString pythonOperator = Generator::pythonOperatorFunctionName(result);
@@ -737,14 +828,16 @@ QString QtDocGenerator::getFuncName(const AbstractMetaFunctionCPtr &cppFunc)
     return result;
 }
 
-void QtDocGenerator::writeParameterType(TextStream &s, const AbstractMetaClass *cppClass,
+void QtDocGenerator::writeParameterType(TextStream &s,
+                                        const AbstractMetaClassCPtr &cppClass,
                                         const AbstractMetaArgument &arg) const
 {
     s << ":param " << arg.name() << ": "
       << translateToPythonType(arg.type(), cppClass) << '\n';
 }
 
-void QtDocGenerator::writeFunctionParametersType(TextStream &s, const AbstractMetaClass *cppClass,
+void QtDocGenerator::writeFunctionParametersType(TextStream &s,
+                                                 const AbstractMetaClassCPtr &cppClass,
                                                  const AbstractMetaFunctionCPtr &func) const
 {
     s << '\n';
@@ -754,36 +847,54 @@ void QtDocGenerator::writeFunctionParametersType(TextStream &s, const AbstractMe
             writeParameterType(s, cppClass, arg);
     }
 
-    if (!func->isConstructor() && !func->isVoid()) {
-
-        QString retType;
+    QString retType;
+    if (!func->isConstructor()) {
         // check if the return type was modified
-        for (const auto &mod : func->modifications()) {
-            for (const ArgumentModification &argMod : mod.argument_mods()) {
-                if (argMod.index() == 0) {
-                    retType = argMod.modifiedType();
-                    break;
-                }
-            }
-        }
-
-        if (retType.isEmpty())
+        retType = func->modifiedTypeName();
+        if (retType.isEmpty() && !func->isVoid())
             retType = translateToPythonType(func->type(), cppClass);
-        s << ":rtype: " << retType << '\n';
     }
+
+    if (!retType.isEmpty())
+        s << ":rtype: " << retType << '\n';
+
     s << '\n';
 }
 
-void QtDocGenerator::writeFunction(TextStream &s, const AbstractMetaClass *cppClass,
-                                   const AbstractMetaFunctionCPtr &func, bool indexed)
+static bool containsFunctionDirective(const DocModification &dm)
 {
-    s << functionSignature(cppClass, func);
+    return dm.mode() != TypeSystem::DocModificationXPathReplace
+        && dm.code().contains(".. py:"_L1);
+}
 
-    {
+void QtDocGenerator::writeFunctions(TextStream &s, const AbstractMetaFunctionCList &funcs,
+                                    const AbstractMetaClassCPtr &cppClass, const QString &scope)
+{
+    QString lastName;
+    for (const auto &func : funcs) {
+        const bool indexed = func->name() != lastName;
+        lastName = func->name();
+        writeFunction(s, func, cppClass, scope, indexed);
+    }
+}
+
+void QtDocGenerator::writeFunction(TextStream &s, const AbstractMetaFunctionCPtr &func,
+                                   const AbstractMetaClassCPtr &cppClass,
+                                   const QString &scope, bool indexed)
+{
+    const auto modifications = DocParser::getDocModifications(func, cppClass);
+
+    // Enable injecting parameter documentation by adding a complete function directive.
+    if (std::none_of(modifications.cbegin(), modifications.cend(), containsFunctionDirective)) {
+        if (func->ownerClass() == nullptr)
+            s << ".. py:function:: ";
+        else
+            s << (func->isStatic() ? ".. py:staticmethod:: " : ".. py:method:: ");
+        s << getFuncName(func) << formatArgs(func);
         Indentation indentation(s);
         if (!indexed)
             s << "\n:noindex:";
-        if (func->attributes().testFlag(AbstractMetaFunction::Attribute::FinalCppMethod))
+        if (func->cppAttributes().testFlag(FunctionAttribute::Final))
             s << "\n:final:";
         else if (func->isAbstract())
             s << "\n:abstractmethod:";
@@ -795,16 +906,12 @@ void QtDocGenerator::writeFunction(TextStream &s, const AbstractMetaClass *cppCl
         if (func->isDeprecated())
             s << rstDeprecationNote("function");
     }
-    writeInjectDocumentation(s, TypeSystem::DocModificationPrepend, cppClass, func);
-    if (!writeInjectDocumentation(s, TypeSystem::DocModificationReplace, cppClass, func)) {
-        writeFormattedBriefText(s, func->documentation(), cppClass);
-        writeFormattedDetailedText(s, func->documentation(), cppClass);
-    }
-    writeInjectDocumentation(s, TypeSystem::DocModificationAppend, cppClass, func);
+
+    writeFunctionDocumentation(s, func, modifications, scope);
 
     if (auto propIndex = func->propertySpecIndex(); propIndex >= 0) {
         const QString name = cppClass->propertySpecs().at(propIndex).name();
-        const QString target = propertyRefTarget(cppClass, name);
+        const QString target = propertyRefTarget(name);
         if (func->isPropertyReader())
             s << "\nGetter of property " << propRef(target) << " .\n\n";
         else if (func->isPropertyWriter())
@@ -816,23 +923,79 @@ void QtDocGenerator::writeFunction(TextStream &s, const AbstractMetaClass *cppCl
     }
 }
 
-static void writeFancyToc(TextStream& s, const QStringList& items)
+void QtDocGenerator::writeFunctionDocumentation(TextStream &s, const AbstractMetaFunctionCPtr &func,
+                                                const DocModificationList &modifications,
+                                                const QString &scope) const
+
+{
+    writeInjectDocumentation(s, TypeSystem::DocModificationPrepend, modifications, func, scope);
+    if (!writeInjectDocumentation(s, TypeSystem::DocModificationReplace, modifications, func, scope)) {
+        writeFormattedBriefText(s, func->documentation(), scope);
+        writeFormattedDetailedText(s, func->documentation(), scope);
+    }
+    writeInjectDocumentation(s, TypeSystem::DocModificationAppend, modifications, func, scope);
+}
+
+static QStringList fileListToToc(const QStringList &items)
+{
+    QStringList result;
+    result.reserve(items.size());
+    std::transform(items.cbegin(), items.cend(), std::back_inserter(result),
+                   fileNameToTocEntry);
+    return result;
+}
+
+static QStringList functionListToToc(const AbstractMetaFunctionCList &functions)
+{
+    QStringList result;
+    result.reserve(functions.size());
+    for (const auto &f : functions)
+        result.append(f->name());
+    // Functions are sorted by the Metabuilder; erase overloads
+    result.erase(std::unique(result.begin(), result.end()), result.end());
+    return result;
+}
+
+static QStringList enumListToToc(const AbstractMetaEnumList &enums)
+{
+    QStringList result;
+    result.reserve(enums.size());
+    for (const auto &e : enums)
+        result.append(e.name());
+    return result;
+}
+
+// Sort entries for a TOC by first character, dropping the
+// leading common Qt prefixes like 'Q'.
+static QChar sortKey(const QString &key)
+{
+    const auto size = key.size();
+    if (size >= 2 && (key.at(0) == u'Q' || key.at(0) == u'q')
+        && (key.at(1).isUpper() || key.at(1).isDigit())) {
+        return key.at(1); // "QClass" -> 'C', "qSin()" -> 'S', 'Q3DSurfaceWidget' -> '3'
+    }
+    if (size >= 3 && key.startsWith("Q_"_L1))
+        return key.at(2).toUpper(); // "Q_ARG" -> 'A'
+    if (size >= 4 && key.startsWith("QT_"_L1))
+        return key.at(3).toUpper(); // "QT_TR" -> 'T'
+    auto idx = 0;
+    for (; idx < size && key.at(idx) == u'_'; ++idx) {
+    } // "__init__" -> 'I'
+    return idx < size ? key.at(idx).toUpper() : u'A';
+}
+
+static void writeFancyToc(TextStream& s, QAnyStringView title,
+                          const QStringList& items,
+                          QLatin1StringView referenceType)
 {
     using TocMap = QMap<QChar, QStringList>;
+
+    if (items.isEmpty())
+        return;
+
     TocMap tocMap;
-    QChar idx;
-    for (QString item : items) {
-        if (item.isEmpty())
-            continue;
-        item.chop(4); // Remove the .rst extension
-        // skip namespace if necessary
-        const QString className = item.split(u'.').last();
-        if (className.startsWith(u'Q') && className.length() > 1)
-            idx = className[1];
-        else
-            idx = className[0];
-        tocMap[idx] << item;
-    }
+    for (const QString &item : items)
+        tocMap[sortKey(item)] << item;
 
     static const qsizetype numColumns = 4;
 
@@ -847,7 +1010,7 @@ static void writeFancyToc(TextStream& s, const QStringList& items)
                 row.clear();
                 row << QtXmlToSphinx::TableCell(QString{});
             }
-            const QString entry = u"* :doc:`"_s + item + u'`';
+            const QString entry = "* :"_L1 + referenceType + ":`"_L1 + item + u'`';
             row << QtXmlToSphinx::TableCell(entry);
         }
         if (row.size() > 1)
@@ -855,33 +1018,44 @@ static void writeFancyToc(TextStream& s, const QStringList& items)
     }
 
     table.normalize();
-    s << ".. container:: pysidetoc\n\n";
+    s << '\n' << headline(title) << ".. container:: pysidetoc\n\n";
     table.format(s);
 }
 
 bool QtDocGenerator::finishGeneration()
 {
-    if (!api().classes().isEmpty())
+    for (const auto &f : api().globalFunctions()) {
+        auto ncf = std::const_pointer_cast<AbstractMetaFunction>(f);
+        m_docParser->fillGlobalFunctionDocumentation(ncf);
+        m_packages[f->targetLangPackage()].globalFunctions.append(f);
+    }
+
+    for (auto e : api().globalEnums()) {
+        m_docParser->fillGlobalEnumDocumentation(e);
+        m_packages[e.typeEntry()->targetLangPackage()].globalEnums.append(e);
+    }
+
+    if (!m_packages.isEmpty())
         writeModuleDocumentation();
-    if (!m_additionalDocumentationList.isEmpty())
+    if (!m_options.additionalDocumentationList.isEmpty())
         writeAdditionalDocumentation();
-    if (!m_inheritanceFile.isEmpty() && !writeInheritanceFile())
+    if (!m_options.inheritanceFile.isEmpty() && !writeInheritanceFile())
         return false;
     return true;
 }
 
 bool QtDocGenerator::writeInheritanceFile()
 {
-    QFile inheritanceFile(m_inheritanceFile);
+    QFile inheritanceFile(m_options.inheritanceFile);
     if (!inheritanceFile.open(QIODevice::WriteOnly | QIODevice::Text))
-        throw Exception(msgCannotOpenForWriting(m_inheritanceFile));
+        throw Exception(msgCannotOpenForWriting(m_options.inheritanceFile));
 
     QJsonObject dict;
-    for (auto *c : api().classes()) {
+    for (const auto &c : api().classes()) {
         const auto &bases = c->baseClasses();
         if (!bases.isEmpty()) {
             QJsonArray list;
-            for (auto *base : bases)
+            for (const auto &base : bases)
                 list.append(QJsonValue(base->fullName()));
             dict[c->fullName()] = list;
         }
@@ -892,11 +1066,22 @@ bool QtDocGenerator::writeInheritanceFile()
     return true;
 }
 
+// Remove function entries that have extra documentation pages
+static inline void removeExtraDocs(const QStringList &extraTocEntries,
+                                   AbstractMetaFunctionCList *functions)
+{
+    auto predicate = [&extraTocEntries](const AbstractMetaFunctionCPtr &f) {
+        return extraTocEntries.contains(f->name());
+    };
+    functions->erase(std::remove_if(functions->begin(),functions->end(), predicate),
+                     functions->end());
+}
+
 void QtDocGenerator::writeModuleDocumentation()
 {
-    QMap<QString, QStringList>::iterator it = m_packages.begin();
-    for (; it != m_packages.end(); ++it) {
-        std::sort(it.value().begin(), it.value().end());
+    for (auto it = m_packages.begin(), end = m_packages.end(); it != end; ++it) {
+        auto &docPackage = it.value();
+        std::sort(docPackage.classPages.begin(), docPackage.classPages.end());
 
         QString key = it.key();
         key.replace(u'.', u'/');
@@ -905,9 +1090,7 @@ void QtDocGenerator::writeModuleDocumentation()
         TextStream& s = output.stream;
 
         const QString &title = it.key();
-        s << ".. module:: " << title << "\n\n"
-            << title << '\n'
-            << Pad('*', title.length()) << "\n\n";
+        s << ".. module:: " << title << "\n\n" << headline(title, '*');
 
         // Store the it.key() in a QString so that it can be stripped off unwanted
         // information when neeeded. For example, the RST files in the extras directory
@@ -918,11 +1101,12 @@ void QtDocGenerator::writeModuleDocumentation()
             moduleName.remove(0, lastIndex + 1);
 
         // Search for extra-sections
-        if (!m_extraSectionDir.isEmpty()) {
-            QDir extraSectionDir(m_extraSectionDir);
+        QStringList extraTocEntries;
+        if (!m_options.extraSectionDir.isEmpty()) {
+            QDir extraSectionDir(m_options.extraSectionDir);
             if (!extraSectionDir.exists()) {
-                const QString m = QStringLiteral("Extra sections directory ") +
-                                  m_extraSectionDir + QStringLiteral(" doesn't exist");
+                const QString m = u"Extra sections directory "_s +
+                                  m_options.extraSectionDir + u" doesn't exist"_s;
                 throw Exception(m);
             }
 
@@ -930,31 +1114,26 @@ void QtDocGenerator::writeModuleDocumentation()
             const QString filter = moduleName + u".?*.rst"_s;
             const auto fileList =
                 extraSectionDir.entryInfoList({filter}, QDir::Files, QDir::Name);
-            for (const auto &fi : fileList) {
-                // Strip to "Property.rst" in output directory
-                const QString newFileName = fi.fileName().mid(moduleName.size() + 1);
-                it.value().append(newFileName);
-                const QString newFilePath = outputDir + u'/' + newFileName;
-                if (QFile::exists(newFilePath))
-                    QFile::remove(newFilePath);
-                if (!QFile::copy(fi.absoluteFilePath(), newFilePath)) {
-                    qCDebug(lcShibokenDoc).noquote().nospace() << "Error copying extra doc "
-                        << QDir::toNativeSeparators(fi.absoluteFilePath())
-                        << " to " << QDir::toNativeSeparators(newFilePath);
-                }
-            }
+            for (const auto &fi : fileList)
+                readExtraDoc(fi, moduleName, outputDir, &docPackage, &extraTocEntries);
         }
 
+        removeExtraDocs(extraTocEntries, &docPackage.globalFunctions);
+        const bool hasGlobals = !docPackage.globalFunctions.isEmpty()
+                                || !docPackage.globalEnums.isEmpty();
+        const QString globalsPage = moduleName + "_globals.rst"_L1;
+
         s << ".. container:: hide\n\n" << indent
             << ".. toctree::\n" << indent
             << ":maxdepth: 1\n\n";
-        for (const QString &className : std::as_const(it.value()))
+        if (hasGlobals)
+            s << globalsPage << '\n';
+        for (const QString &className : std::as_const(docPackage.classPages))
             s << className << '\n';
-        s << "\n\n" << outdent << outdent
-            << "Detailed Description\n--------------------\n\n";
+        s << "\n\n" << outdent << outdent << headline("Detailed Description");
 
         // module doc is always wrong and C++istic, so go straight to the extra directory!
-        QFile moduleDoc(m_extraSectionDir + u'/' + moduleName
+        QFile moduleDoc(m_options.extraSectionDir + u'/' + moduleName
                         + u".rst"_s);
         if (moduleDoc.open(QIODevice::ReadOnly | QIODevice::Text)) {
             s << moduleDoc.readAll();
@@ -965,19 +1144,48 @@ void QtDocGenerator::writeModuleDocumentation()
             if (moduleDoc.format() == Documentation::Native) {
                 QString context = it.key();
                 QtXmlToSphinx::stripPythonQualifiers(&context);
-                QtXmlToSphinx x(this, m_parameters, moduleDoc.detailed(), context);
+                QtXmlToSphinx x(this, m_options.parameters, moduleDoc.detailed(), context);
                 s << x;
             } else {
                 s << moduleDoc.detailed();
             }
         }
 
-        s << "\nList of Classes\n"
-            << "---------------\n\n";
-        writeFancyToc(s, it.value());
+        writeFancyToc(s, "List of Classes", fileListToToc(docPackage.classPages),
+                      "class"_L1);
+        writeFancyToc(s, "List of Decorators", fileListToToc(docPackage.decoratorPages),
+                      "deco"_L1);
+        writeFancyToc(s, "List of Functions", functionListToToc(docPackage.globalFunctions),
+                      "py:func"_L1);
+        writeFancyToc(s, "List of Enumerations", enumListToToc(docPackage.globalEnums),
+                      "any"_L1);
 
         output.done();
+
+        if (hasGlobals)
+            writeGlobals(it.key(), outputDir + u'/' + globalsPage, docPackage);
+    }
+}
+
+void QtDocGenerator::writeGlobals(const QString &package,
+                                  const QString &fileName,
+                                  const DocPackage &docPackage)
+{
+    FileOut output(fileName);
+    TextStream &s = output.stream;
+
+    // Write out functions with injected documentation
+    if (!docPackage.globalFunctions.isEmpty()) {
+        s << currentModule(package) << headline("Functions");
+        writeFunctions(s, docPackage.globalFunctions, {}, {});
     }
+
+    if (!docPackage.globalEnums.isEmpty()) {
+        s << headline("Enumerations");
+        writeEnums(s, docPackage.globalEnums, package);
+    }
+
+    output.done();
 }
 
 static inline QString msgNonExistentAdditionalDocFile(const QString &dir,
@@ -992,7 +1200,7 @@ static inline QString msgNonExistentAdditionalDocFile(const QString &dir,
 
 void QtDocGenerator::writeAdditionalDocumentation() const
 {
-    QFile additionalDocumentationFile(m_additionalDocumentationList);
+    QFile additionalDocumentationFile(m_options.additionalDocumentationList);
     if (!additionalDocumentationFile.open(QIODevice::ReadOnly | QIODevice::Text))
         throw Exception(msgCannotOpenForReading(additionalDocumentationFile));
 
@@ -1017,8 +1225,8 @@ void QtDocGenerator::writeAdditionalDocumentation() const
                 targetDir = outDir.absolutePath();
             } else {
                 if (!outDir.exists(dir) && !outDir.mkdir(dir)) {
-                    const QString m = QStringLiteral("Cannot create directory ")
-                                      + dir + QStringLiteral(" under ")
+                    const QString m = "Cannot create directory "_L1
+                                      + dir + " under "_L1
                                       + QDir::toNativeSeparators(outputDirectory());
                     throw Exception(m);
                 }
@@ -1026,7 +1234,7 @@ void QtDocGenerator::writeAdditionalDocumentation() const
             }
         } else {
             // Normal file entry
-            QFileInfo fi(m_parameters.docDataDir + u'/' + line);
+            QFileInfo fi(m_options.parameters.docDataDir + u'/' + line);
             if (fi.isFile()) {
                 const QString rstFileName = fi.baseName() + rstSuffix;
                 const QString rstFile = targetDir + u'/' + rstFileName;
@@ -1044,7 +1252,7 @@ void QtDocGenerator::writeAdditionalDocumentation() const
                 // FIXME: This should be an exception, in principle, but it
                 // requires building all modules.
                 qCWarning(lcShibokenDoc, "%s",
-                          qPrintable(msgNonExistentAdditionalDocFile(m_parameters.docDataDir, line)));
+                          qPrintable(msgNonExistentAdditionalDocFile(m_options.parameters.docDataDir, line)));
             }
             ++count;
         }
@@ -1063,32 +1271,34 @@ void QtDocGenerator::writeAdditionalDocumentation() const
 
 bool QtDocGenerator::doSetup()
 {
-    if (m_parameters.codeSnippetDirs.isEmpty()) {
-        m_parameters.codeSnippetDirs =
-            m_parameters.libSourceDir.split(QLatin1Char(PATH_SEP));
+    if (m_options.parameters.codeSnippetDirs.isEmpty()) {
+        m_options.parameters.codeSnippetDirs =
+            m_options.parameters.libSourceDir.split(QLatin1Char(PATH_SEP));
     }
 
-    if (m_docParser.isNull())
-        m_docParser.reset(new QtDocParser);
+    if (m_docParser.isNull()) {
+        if (m_options.doxygen)
+            m_docParser.reset(new DoxygenParser);
+        else
+            m_docParser.reset(new QtDocParser);
+    }
 
-    if (m_parameters.libSourceDir.isEmpty()
-        || m_parameters.docDataDir.isEmpty()) {
+    if (m_options.parameters.libSourceDir.isEmpty()
+        || m_options.parameters.docDataDir.isEmpty()) {
         qCWarning(lcShibokenDoc) << "Documentation data dir and/or Qt source dir not informed, "
                                  "documentation will not be extracted from Qt sources.";
         return false;
     }
 
-    m_docParser->setDocumentationDataDirectory(m_parameters.docDataDir);
-    m_docParser->setLibrarySourceDirectory(m_parameters.libSourceDir);
-    m_parameters.outputDirectory = outputDirectory();
+    m_docParser->setDocumentationDataDirectory(m_options.parameters.docDataDir);
+    m_docParser->setLibrarySourceDirectory(m_options.parameters.libSourceDir);
+    m_options.parameters.outputDirectory = outputDirectory();
     return true;
 }
 
-
-Generator::OptionDescriptions QtDocGenerator::options() const
+QList<OptionDescription> QtDocGenerator::options()
 {
-    auto result = Generator::options();
-    result.append({
+    return {
         {u"doc-parser=<parser>"_s,
          u"The documentation parser used to interpret the documentation\n"
           "input files (qdoc|doxygen)"_s},
@@ -1102,30 +1312,52 @@ Generator::OptionDescriptions QtDocGenerator::options() const
          u"Directory used to search for extra documentation sections"_s},
         {u"library-source-dir=<dir>"_s,
          u"Directory where library source code is located"_s},
-        {additionalDocumentationOption() + u"=<file>"_s,
+        {additionalDocumentationOption + u"=<file>"_s,
          u"List of additional XML files to be converted to .rst files\n"
           "(for example, tutorials)."_s},
         {u"inheritance-file=<file>"_s,
-         u"Generate a JSON file containing the class inheritance."_s}
-
-    });
-    return result;
+         u"Generate a JSON file containing the class inheritance."_s},
+        {u"disable-inheritance-diagram"_s,
+         u"Disable the generation of the inheritance diagram."_s}
+    };
 }
 
-bool QtDocGenerator::handleOption(const QString &key, const QString &value)
+class QtDocGeneratorOptionsParser : public OptionsParser
 {
-    if (Generator::handleOption(key, value))
+public:
+    explicit QtDocGeneratorOptionsParser(DocGeneratorOptions *o) : m_options(o) {}
+
+    bool handleBoolOption(const QString &key, OptionSource source) override;
+    bool handleOption(const QString &key, const QString &value, OptionSource source) override;
+
+private:
+    DocGeneratorOptions *m_options;
+};
+
+bool QtDocGeneratorOptionsParser::handleBoolOption(const QString &key, OptionSource)
+{
+    if (key == "disable-inheritance-diagram"_L1) {
+        m_options->inheritanceDiagram = false;
         return true;
+    }
+    return false;
+}
+
+bool QtDocGeneratorOptionsParser::handleOption(const QString &key, const QString &value,
+                                               OptionSource source)
+{
+    if (source == OptionSource::CommandLineSingleDash)
+        return false;
     if (key == u"library-source-dir") {
-        m_parameters.libSourceDir = value;
+        m_options->parameters.libSourceDir = value;
         return true;
     }
     if (key == u"documentation-data-dir") {
-        m_parameters.docDataDir = value;
+        m_options->parameters.docDataDir = value;
         return true;
     }
     if (key == u"documentation-code-snippets-dir") {
-        m_parameters.codeSnippetDirs = value.split(QLatin1Char(PATH_SEP));
+        m_options->parameters.codeSnippetDirs = value.split(QLatin1Char(PATH_SEP));
         return true;
     }
 
@@ -1133,34 +1365,39 @@ bool QtDocGenerator::handleOption(const QString &key, const QString &value)
         const auto pos = value.indexOf(u':');
         if (pos == -1)
             return false;
-        m_parameters.codeSnippetRewriteOld= value.left(pos);
-        m_parameters.codeSnippetRewriteNew = value.mid(pos + 1);
+        m_options->parameters.codeSnippetRewriteOld= value.left(pos);
+        m_options->parameters.codeSnippetRewriteNew = value.mid(pos + 1);
         return true;
     }
 
     if (key == u"documentation-extra-sections-dir") {
-        m_extraSectionDir = value;
+        m_options->extraSectionDir = value;
         return true;
     }
     if (key == u"doc-parser") {
         qCDebug(lcShibokenDoc).noquote().nospace() << "doc-parser: " << value;
         if (value == u"doxygen")
-            m_docParser.reset(new DoxygenParser);
+            m_options->doxygen = true;
         return true;
     }
-    if (key == additionalDocumentationOption()) {
-        m_additionalDocumentationList = value;
+    if (key == additionalDocumentationOption) {
+        m_options->additionalDocumentationList = value;
         return true;
     }
 
     if (key == u"inheritance-file") {
-        m_inheritanceFile = value;
+        m_options->inheritanceFile = value;
         return true;
     }
 
     return false;
 }
 
+std::shared_ptr<OptionsParser> QtDocGenerator::createOptionsParser()
+{
+    return std::make_shared<QtDocGeneratorOptionsParser>(&m_options);
+}
+
 bool QtDocGenerator::convertToRst(const QString &sourceFileName,
                                   const QString &targetFileName,
                                   const QString &context,
@@ -1176,28 +1413,22 @@ bool QtDocGenerator::convertToRst(const QString &sourceFileName,
     sourceFile.close();
 
     FileOut targetFile(targetFileName);
-    QtXmlToSphinx x(this, m_parameters, doc, context);
+    QtXmlToSphinx x(this, m_options.parameters, doc, context);
     targetFile.stream << x;
     targetFile.done();
     return true;
 }
 
 GeneratorDocumentation
-    QtDocGenerator::generatorDocumentation(const AbstractMetaClass *cppClass) const
+    QtDocGenerator::generatorDocumentation(const AbstractMetaClassCPtr &cppClass)
 {
     GeneratorDocumentation result;
     const auto allFunctions = cppClass->functions();
     result.allFunctions.reserve(allFunctions.size());
-    for (const auto &func : allFunctions) {
-        if (!shouldSkip(func)) {
-            if (func->isConstructor())
-                result.constructors.append(func);
-            else
-                result.allFunctions.append(func);
-        }
-    }
+    std::remove_copy_if(allFunctions.cbegin(), allFunctions.cend(),
+                        std::back_inserter(result.allFunctions), shouldSkip);
 
-    std::sort(result.allFunctions.begin(), result.allFunctions.end(), functionSort);
+    std::stable_sort(result.allFunctions.begin(), result.allFunctions.end(), functionSort);
 
     for (const auto &func : std::as_const(result.allFunctions)) {
         if (func->isStatic())
@@ -1236,11 +1467,11 @@ GeneratorDocumentation
 // QtXmlToSphinxDocGeneratorInterface
 QString QtDocGenerator::expandFunction(const QString &function) const
 {
-    const int firstDot = function.indexOf(u'.');
-    const AbstractMetaClass *metaClass = nullptr;
+    const auto firstDot = function.indexOf(u'.');
+    AbstractMetaClassCPtr metaClass;
     if (firstDot != -1) {
         const auto className = QStringView{function}.left(firstDot);
-        for (auto cls : api().classes()) {
+        for (const auto &cls : api().classes()) {
             if (cls->name() == className) {
                 metaClass = cls;
                 break;
@@ -1275,8 +1506,8 @@ QString QtDocGenerator::resolveContextForMethod(const QString &context,
 {
     const auto currentClass = QStringView{context}.split(u'.').constLast();
 
-    const AbstractMetaClass *metaClass = nullptr;
-    for (auto cls : api().classes()) {
+    AbstractMetaClassCPtr metaClass;
+    for (const auto &cls : api().classes()) {
         if (cls->name() == currentClass) {
             metaClass = cls;
             break;
@@ -1291,7 +1522,7 @@ QString QtDocGenerator::resolveContextForMethod(const QString &context,
                 funcList.append(func);
         }
 
-        const AbstractMetaClass *implementingClass = nullptr;
+        AbstractMetaClassCPtr implementingClass;
         for (const auto &func : std::as_const(funcList)) {
             implementingClass = func->implementingClass();
             if (implementingClass->name() == currentClass)
@@ -1322,7 +1553,7 @@ QtXmlToSphinxLink QtDocGenerator::resolveLink(const QtXmlToSphinxLink &link) con
 {
     if (link.type != QtXmlToSphinxLink::Reference || !isRelativeHtmlFile(link.linkRef))
         return link;
-    static const QString prefix = QStringLiteral("https://doc.qt.io/qt-")
+    static const QString prefix = "https://doc.qt.io/qt-"_L1
         + QString::number(QT_VERSION_MAJOR) + u'/';
     QtXmlToSphinxLink resolved = link;
     resolved.type = QtXmlToSphinxLink::External;
@@ -1333,6 +1564,28 @@ QtXmlToSphinxLink QtDocGenerator::resolveLink(const QtXmlToSphinxLink &link) con
         if (anchor != -1)
             resolved.linkText.truncate(anchor);
     }
-    qDebug() << __FUNCTION__ << link << "->" << resolved;
     return resolved;
 }
+
+QtXmlToSphinxDocGeneratorInterface::Image
+    QtDocGenerator::resolveImage(const QString &href, const QString &context) const
+{
+    QString relativeSourceDir = href;
+    const QString source = m_options.parameters.docDataDir + u'/' + relativeSourceDir;
+    if (!QFileInfo::exists(source))
+        throw Exception(msgCannotFindImage(href, context,source));
+
+    // Determine target directory from context, "Pyside2.QtGui.QPainter" ->"Pyside2/QtGui".
+    // FIXME: Not perfect yet, should have knowledge about namespaces (DataVis3D) or
+    // nested classes "Pyside2.QtGui.QTouchEvent.QTouchPoint".
+    QString relativeTargetDir = context;
+    const auto lastDot = relativeTargetDir.lastIndexOf(u'.');
+    if (lastDot != -1)
+        relativeTargetDir.truncate(lastDot);
+    relativeTargetDir.replace(u'.', u'/');
+    if (!relativeTargetDir.isEmpty())
+        relativeTargetDir += u'/';
+    relativeTargetDir += href;
+
+    return {relativeSourceDir, relativeTargetDir};
+}
diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.h b/sources/shiboken6/generator/qtdoc/qtdocgenerator.h
index af4b60d2e..56e15e2a1 100644
--- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.h
+++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.h
@@ -9,13 +9,15 @@
 
 #include "generator.h"
 #include "documentation.h"
+#include <optionsparser.h>
 #include "typesystem_enums.h"
 #include "modifications_typedefs.h"
 #include "qtxmltosphinxinterface.h"
 
 class DocParser;
-
+struct DocGeneratorOptions;
 struct GeneratorDocumentation;
+struct DocPackage;
 
 /**
 *   The DocGenerator generates documentation from library being binded.
@@ -23,6 +25,8 @@ struct GeneratorDocumentation;
 class QtDocGenerator : public Generator, public QtXmlToSphinxDocGeneratorInterface
 {
 public:
+    Q_DISABLE_COPY_MOVE(QtDocGenerator)
+
     QtDocGenerator();
     ~QtDocGenerator();
 
@@ -33,8 +37,8 @@ public:
         return "QtDocGenerator";
     }
 
-    OptionDescriptions options() const override;
-    bool handleOption(const QString &key, const QString &value) override;
+    static QList<OptionDescription> options();
+    static std::shared_ptr<OptionsParser> createOptionsParser();
 
     // QtXmlToSphinxDocGeneratorInterface
     QString expandFunction(const QString &function) const override;
@@ -44,6 +48,7 @@ public:
                                     const QString &methodName) const override;
     const QLoggingCategory &loggingCategory() const override;
     QtXmlToSphinxLink resolveLink(const QtXmlToSphinxLink &) const override;
+    Image resolveImage(const QString &href, const QString &context) const override;
 
     static QString getFuncName(const AbstractMetaFunctionCPtr &cppFunc);
     static QString formatArgs(const AbstractMetaFunctionCPtr &func);
@@ -56,50 +61,57 @@ protected:
     bool finishGeneration() override;
 
 private:
-    void writeEnums(TextStream &s, const AbstractMetaClass *cppClass) const;
-
-    void writeFields(TextStream &s, const AbstractMetaClass *cppClass) const;
-    static QString functionSignature(const AbstractMetaClass *cppClass,
-                                     const AbstractMetaFunctionCPtr &func);
-    void writeFunction(TextStream &s, const AbstractMetaClass *cppClass,
-                       const AbstractMetaFunctionCPtr &func, bool indexed = true);
-    void writeFunctionParametersType(TextStream &s, const AbstractMetaClass *cppClass,
+    void writeEnums(TextStream &s, const AbstractMetaEnumList &enums,
+                    const QString &scope) const;
+
+    void writeFields(TextStream &s, const AbstractMetaClassCPtr &cppClass) const;
+    void writeFunctions(TextStream &s, const AbstractMetaFunctionCList &funcs,
+                        const AbstractMetaClassCPtr &cppClass, const QString &scope);
+    void writeFunction(TextStream &s, const AbstractMetaFunctionCPtr &func,
+                       const AbstractMetaClassCPtr &cppClass = {},
+                       const QString &scope = {}, bool indexed = true);
+    void writeFunctionDocumentation(TextStream &s, const AbstractMetaFunctionCPtr &func,
+                                    const DocModificationList &modifications,
+                                    const QString &scope) const;
+    void writeFunctionParametersType(TextStream &s, const AbstractMetaClassCPtr &cppClass,
                                      const AbstractMetaFunctionCPtr &func) const;
     static void writeFunctionToc(TextStream &s, const QString &title,
-                                 const AbstractMetaClass *cppClass,
                                  const AbstractMetaFunctionCList &functions);
-    void writePropertyToc(TextStream &s,
-                          const GeneratorDocumentation &doc,
-                          const AbstractMetaClass *cppClass);
+    static void writePropertyToc(TextStream &s,
+                                 const GeneratorDocumentation &doc);
     void writeProperties(TextStream &s,
                          const GeneratorDocumentation &doc,
-                         const AbstractMetaClass *cppClass) const;
-    void writeParameterType(TextStream &s, const AbstractMetaClass *cppClass,
+                         const AbstractMetaClassCPtr &cppClass) const;
+    void writeParameterType(TextStream &s, const AbstractMetaClassCPtr &cppClass,
                             const AbstractMetaArgument &arg) const;
-
-    void writeConstructors(TextStream &s,
-                           const AbstractMetaClass *cppClass,
-                           const AbstractMetaFunctionCList &constructors) const;
-
     void writeFormattedText(TextStream &s, const QString &doc,
                             Documentation::Format format,
-                            const AbstractMetaClass *metaClass = nullptr) const;
+                            const QString &scope = {}) const;
     void writeFormattedBriefText(TextStream &s, const Documentation &doc,
-                                 const AbstractMetaClass *metaclass = nullptr) const;
+                                 const QString &scope = {}) const;
     void writeFormattedDetailedText(TextStream &s, const Documentation &doc,
-                                    const AbstractMetaClass *metaclass = nullptr) const;
+                                    const QString &scope = {}) const;
 
     bool writeInjectDocumentation(TextStream &s, TypeSystem::DocModificationMode mode,
-                                  const AbstractMetaClass *cppClass,
-                                  const AbstractMetaFunctionCPtr &func);
+                                  const AbstractMetaClassCPtr &cppClass) const;
+    bool writeInjectDocumentation(TextStream &s, TypeSystem::DocModificationMode mode,
+                                  const DocModificationList &modifications,
+                                  const AbstractMetaFunctionCPtr &func,
+                                  const QString &scope = {}) const;
+    bool writeDocModifications(TextStream &s, const DocModificationList &mods,
+                               TypeSystem::DocModificationMode mode,
+                               const QString &scope = {}) const;
     static void writeDocSnips(TextStream &s, const CodeSnipList &codeSnips,
                               TypeSystem::CodeSnipPosition position, TypeSystem::Language language);
 
     void writeModuleDocumentation();
+    void writeGlobals(const QString &package, const QString &fileName,
+                      const DocPackage &docPackage);
     void writeAdditionalDocumentation() const;
     bool writeInheritanceFile();
 
-    QString translateToPythonType(const AbstractMetaType &type, const AbstractMetaClass *cppClass,
+    QString translateToPythonType(const AbstractMetaType &type,
+                                  const AbstractMetaClassCPtr &cppClass,
                                   bool createRef = true) const;
 
     bool convertToRst(const QString &sourceFileName,
@@ -107,15 +119,12 @@ private:
                       const QString &context = QString(),
                       QString *errorMessage = nullptr) const;
 
-    GeneratorDocumentation generatorDocumentation(const AbstractMetaClass *cppClass) const;
+    static GeneratorDocumentation generatorDocumentation(const AbstractMetaClassCPtr &cppClass);
 
-    QString m_extraSectionDir;
     QStringList m_functionList;
-    QMap<QString, QStringList> m_packages;
+    QMap<QString, DocPackage> m_packages;
     QScopedPointer<DocParser> m_docParser;
-    QtXmlToSphinxParameters m_parameters;
-    QString m_additionalDocumentationList;
-    QString m_inheritanceFile;
+    static DocGeneratorOptions m_options;
 };
 
 #endif // DOCGENERATOR_H
diff --git a/sources/shiboken6/generator/qtdoc/qtxmltosphinx.cpp b/sources/shiboken6/generator/qtdoc/qtxmltosphinx.cpp
index 222320d38..b8fec836c 100644
--- a/sources/shiboken6/generator/qtdoc/qtxmltosphinx.cpp
+++ b/sources/shiboken6/generator/qtdoc/qtxmltosphinx.cpp
@@ -19,10 +19,6 @@
 
 using namespace Qt::StringLiterals;
 
-static inline QString nameAttribute() { return QStringLiteral("name"); }
-static inline QString titleAttribute() { return QStringLiteral("title"); }
-static inline QString fullTitleAttribute() { return QStringLiteral("fulltitle"); }
-
 QString msgTagWarning(const QXmlStreamReader &reader, const QString &context,
                       const QString &tag, const QString &message)
 {
@@ -63,6 +59,20 @@ static bool isHttpLink(const QString &ref)
     return ref.startsWith(u"http://") || ref.startsWith(u"https://");
 }
 
+static QString trimRight(QString s)
+{
+    while (!s.isEmpty() && s.crbegin()->isSpace())
+        s.chop(1);
+    return s;
+}
+
+static QString trimLeadingNewlines(QString s)
+{
+    while (!s.isEmpty() && s.at(0) == u'\n')
+        s.remove(0, 1);
+    return s;
+}
+
 QDebug operator<<(QDebug d, const QtXmlToSphinxLink &l)
 {
     static const QHash<QtXmlToSphinxLink::Type, const char *> typeName = {
@@ -407,32 +417,49 @@ void QtXmlToSphinx::callHandler(WebXmlTag t, QXmlStreamReader &r)
 
 void QtXmlToSphinx::formatCurrentTable()
 {
-    if (m_currentTable.isEmpty())
+    Q_ASSERT(!m_tables.isEmpty());
+    auto &table = m_tables.back();
+    if (table.isEmpty())
         return;
-    m_currentTable.normalize();
+    table.normalize();
     m_output << '\n';
-    m_currentTable.format(m_output);
+    table.format(m_output);
 }
 
 void QtXmlToSphinx::pushOutputBuffer()
 {
-    m_buffers.append(StringSharedPtr(new QString{}));
-    m_output.setString(m_buffers.top().data());
+    m_buffers.append(std::make_shared<QString>());
+    m_output.setString(m_buffers.top().get());
 }
 
 QString QtXmlToSphinx::popOutputBuffer()
 {
     Q_ASSERT(!m_buffers.isEmpty());
-    QString result(*m_buffers.top().data());
+    QString result(*m_buffers.top());
     m_buffers.pop();
-    m_output.setString(m_buffers.isEmpty() ? nullptr : m_buffers.top().data());
+    m_output.setString(m_buffers.isEmpty() ? nullptr : m_buffers.top().get());
     return result;
 }
 
+constexpr auto autoTranslatedPlaceholder = "AUTO_GENERATED\n"_L1;
+constexpr auto autoTranslatedNote =
+R"(.. warning::
+    This section contains snippets that were automatically
+    translated from C++ to Python and may contain errors.
+
+)"_L1;
+
+void QtXmlToSphinx::setAutoTranslatedNote(QString *str) const
+{
+    if (m_containsAutoTranslations)
+        str->replace(autoTranslatedPlaceholder, autoTranslatedNote);
+    else
+        str->remove(autoTranslatedPlaceholder);
+}
+
 QString QtXmlToSphinx::transform(const QString& doc)
 {
     Q_ASSERT(m_buffers.isEmpty());
-    Indentation indentation(m_output);
     if (doc.trimmed().isEmpty())
         return doc;
 
@@ -440,6 +467,9 @@ QString QtXmlToSphinx::transform(const QString& doc)
 
     QXmlStreamReader reader(doc);
 
+    m_output << autoTranslatedPlaceholder;
+    Indentation indentation(m_output);
+
     while (!reader.atEnd()) {
         QXmlStreamReader::TokenType token = reader.readNext();
         if (reader.hasError()) {
@@ -480,6 +510,7 @@ QString QtXmlToSphinx::transform(const QString& doc)
     m_output.flush();
     QString retval = popOutputBuffer();
     Q_ASSERT(m_buffers.isEmpty());
+    setAutoTranslatedNote(&retval);
     return retval;
 }
 
@@ -528,7 +559,7 @@ static QString pySnippetName(const QString &path, SnippetType type)
 QtXmlToSphinx::Snippet QtXmlToSphinx::readSnippetFromLocations(const QString &path,
                                                 const QString &identifier,
                                                 const QString &fallbackPath,
-                                                QString *errorMessage) const
+                                                QString *errorMessage)
 {
     // For anything else but C++ header/sources (no conversion to Python),
     // use existing fallback paths first.
@@ -550,6 +581,7 @@ QtXmlToSphinx::Snippet QtXmlToSphinx::readSnippetFromLocations(const QString &pa
                 rewrittenPath.replace(m_parameters.codeSnippetRewriteOld,
                                       m_parameters.codeSnippetRewriteNew);
                 const QString code = readFromLocation(rewrittenPath, identifier, errorMessage);
+                m_containsAutoTranslations = true;
                 return {code, code.isNull() ? Snippet::Error : Snippet::Converted};
             }
         }
@@ -561,7 +593,7 @@ QtXmlToSphinx::Snippet QtXmlToSphinx::readSnippetFromLocations(const QString &pa
         }
     }
 
-    resolvedPath =resolveFile(locations, path);
+    resolvedPath = resolveFile(locations, path);
     if (!resolvedPath.isEmpty()) {
         const QString code = readFromLocation(resolvedPath, identifier, errorMessage);
         return {code, code.isNull() ? Snippet::Error : Snippet::Resolved};
@@ -577,6 +609,88 @@ QtXmlToSphinx::Snippet QtXmlToSphinx::readSnippetFromLocations(const QString &pa
     return {{}, Snippet::Error};
 }
 
+// Helpers for extracting qdoc snippets "#/// [id]"
+static QString fileNameOfDevice(const QIODevice *inputFile)
+{
+    const auto *file = qobject_cast<const QFile *>(inputFile);
+    return file ? QDir::toNativeSeparators(file->fileName()) : u"<stdin>"_s;
+}
+
+static QString msgSnippetNotFound(const QIODevice &inputFile,
+                                  const QString &identifier)
+{
+    return u"Code snippet file found ("_s + fileNameOfDevice(&inputFile)
+           + u"), but snippet ["_s + identifier + u"] not found."_s;
+}
+
+static QString msgEmptySnippet(const QIODevice &inputFile, int lineNo,
+                               const QString &identifier)
+{
+    return u"Empty code snippet ["_s + identifier + u"] at "_s
+           + fileNameOfDevice(&inputFile) + u':' + QString::number(lineNo);
+}
+
+// Pattern to match qdoc snippet IDs with "#/// [id]" comments and helper to find ID
+static const QRegularExpression &snippetIdPattern()
+{
+    static const QRegularExpression result(uR"RX((//|#) *! *\[([^]]+)\])RX"_s);
+    Q_ASSERT(result.isValid());
+    return result;
+}
+
+static bool matchesSnippetId(QRegularExpressionMatchIterator it,
+                             const QString &identifier)
+{
+    while (it.hasNext()) {
+        if (it.next().captured(2) == identifier)
+            return true;
+    }
+    return false;
+}
+
+QString QtXmlToSphinx::readSnippet(QIODevice &inputFile, const QString &identifier,
+                                   QString *errorMessage)
+{
+    const QByteArray identifierBA = identifier.toUtf8();
+    // Lambda that matches the snippet id
+    const auto snippetIdPred = [&identifierBA, &identifier](const QByteArray &lineBA)
+    {
+        const bool isComment = lineBA.contains('/') || lineBA.contains('#');
+        if (!isComment || !lineBA.contains(identifierBA))
+            return false;
+        const QString line = QString::fromUtf8(lineBA);
+        return matchesSnippetId(snippetIdPattern().globalMatch(line), identifier);
+    };
+
+    // Find beginning, skip over
+    int lineNo = 1;
+    for (; !inputFile.atEnd() && !snippetIdPred(inputFile.readLine());
+         ++lineNo) {
+    }
+
+    if (inputFile.atEnd()) {
+        *errorMessage = msgSnippetNotFound(inputFile, identifier);
+        return {};
+    }
+
+    QString code;
+    for (; !inputFile.atEnd(); ++lineNo) {
+        const QString line = QString::fromUtf8(inputFile.readLine());
+        auto it = snippetIdPattern().globalMatch(line);
+        if (it.hasNext()) { // Skip snippet id lines
+            if (matchesSnippetId(it, identifier))
+                break;
+        } else {
+            code += line;
+        }
+    }
+
+    if (code.isEmpty())
+        *errorMessage = msgEmptySnippet(inputFile, lineNo, identifier);
+
+    return code;
+}
+
 QString QtXmlToSphinx::readFromLocation(const QString &location, const QString &identifier,
                                         QString *errorMessage)
 {
@@ -586,7 +700,7 @@ QString QtXmlToSphinx::readFromLocation(const QString &location, const QString &
         QTextStream(errorMessage) << "Could not read code snippet file: "
             << QDir::toNativeSeparators(inputFile.fileName())
             << ": " << inputFile.errorString();
-        return QString(); // null
+        return {}; // null
     }
 
     QString code = u""_s; // non-null
@@ -596,37 +710,8 @@ QString QtXmlToSphinx::readFromLocation(const QString &location, const QString &
         return CodeSnipHelpers::fixSpaces(code);
     }
 
-    const QRegularExpression searchString(u"//!\\s*\\["_s
-                                          + identifier + u"\\]"_s);
-    Q_ASSERT(searchString.isValid());
-    static const QRegularExpression cppCodeSnippetCode(u"//!\\s*\\[[\\w\\d\\s]+\\]"_s);
-    Q_ASSERT(cppCodeSnippetCode.isValid());
-    static const QRegularExpression pythonCodeSnippetCode(u"#!\\s*\\[[\\w\\d\\s]+\\]"_s);
-    Q_ASSERT(pythonCodeSnippetCode.isValid());
-
-    bool getCode = false;
-
-    while (!inputFile.atEnd()) {
-        QString line = QString::fromUtf8(inputFile.readLine());
-        if (getCode && !line.contains(searchString)) {
-            line.remove(cppCodeSnippetCode);
-            line.remove(pythonCodeSnippetCode);
-            code += line;
-        } else if (line.contains(searchString)) {
-            if (getCode)
-                break;
-            getCode = true;
-        }
-    }
-
-    if (!getCode) {
-        QTextStream(errorMessage) << "Code snippet file found ("
-            << QDir::toNativeSeparators(location) << "), but snippet ["
-            << identifier << "] not found.";
-        return QString(); // null
-    }
-
-    return CodeSnipHelpers::fixSpaces(code);
+    code = readSnippet(inputFile, identifier, errorMessage);
+    return code.isEmpty() ? QString{} : CodeSnipHelpers::fixSpaces(code); // maintain isNull()
 }
 
 void QtXmlToSphinx::handleHeadingTag(QXmlStreamReader& reader)
@@ -689,9 +774,9 @@ void QtXmlToSphinx::handleParaTagEnd()
 {
     QString result = popOutputBuffer().simplified();
     if (result.startsWith(u"**Warning:**"))
-        result.replace(0, 12, QStringLiteral(".. warning:: "));
+        result.replace(0, 12, ".. warning:: "_L1);
     else if (result.startsWith(u"**Note:**"))
-        result.replace(0, 9, QStringLiteral(".. note:: "));
+        result.replace(0, 9, ".. note:: "_L1);
     m_output << result << "\n\n";
 }
 
@@ -760,23 +845,23 @@ void QtXmlToSphinx::handleArgumentTag(QXmlStreamReader& reader)
     }
 }
 
-static inline QString functionLinkType() { return QStringLiteral("function"); }
-static inline QString classLinkType() { return QStringLiteral("class"); }
+constexpr auto functionLinkType = "function"_L1;
+constexpr auto classLinkType = "class"_L1;
 
 static inline QString fixLinkType(QStringView type)
 {
     // TODO: create a flag PROPERTY-AS-FUNCTION to ask if the properties
     // are recognized as such or not in the binding
     if (type == u"property")
-        return functionLinkType();
+        return functionLinkType;
     if (type == u"typedef")
-        return classLinkType();
+        return classLinkType;
     return type.toString();
 }
 
 static inline QString linkSourceAttribute(const QString &type)
 {
-    if (type == functionLinkType() || type == classLinkType())
+    if (type == functionLinkType || type == classLinkType)
         return u"raw"_s;
     return type == u"enum" || type == u"page"
         ? type : u"href"_s;
@@ -802,7 +887,7 @@ void QtXmlToSphinx::handleSeeAlsoTag(QXmlStreamReader& reader)
             const QString text = textR.toString();
             if (m_seeAlsoContext.isNull()) {
                 const QString type = text.endsWith(u"()")
-                    ? functionLinkType() : classLinkType();
+                    ? functionLinkType : classLinkType;
                 m_seeAlsoContext.reset(handleLinkStart(type, text));
             }
             handleLinkText(m_seeAlsoContext.data(), text);
@@ -821,7 +906,7 @@ void QtXmlToSphinx::handleSeeAlsoTag(QXmlStreamReader& reader)
     }
 }
 
-static inline QString fallbackPathAttribute() { return QStringLiteral("path"); }
+constexpr auto fallbackPathAttribute = "path"_L1;
 
 template <class Indent> // const char*/class Indentor
 void formatSnippet(TextStream &str, Indent indent, const QString &snippet)
@@ -856,14 +941,15 @@ void QtXmlToSphinx::handleSnippetTag(QXmlStreamReader& reader)
             || m_lastTagName == u"dots" || m_lastTagName == u"codeline";
         if (consecutiveSnippet) {
             m_output.flush();
-            m_output.string()->chop(2);
+            m_output.string()->chop(1); // Strip newline from previous snippet
         }
         QString location = reader.attributes().value(u"location"_s).toString();
         QString identifier = reader.attributes().value(u"identifier"_s).toString();
         QString fallbackPath;
-        if (reader.attributes().hasAttribute(fallbackPathAttribute()))
-            fallbackPath = reader.attributes().value(fallbackPathAttribute()).toString();
+        if (reader.attributes().hasAttribute(fallbackPathAttribute))
+            fallbackPath = reader.attributes().value(fallbackPathAttribute).toString();
         QString errorMessage;
+
         const Snippet snippet = readSnippetFromLocations(location, identifier,
                                                          fallbackPath, &errorMessage);
         if (!errorMessage.isEmpty())
@@ -886,6 +972,7 @@ void QtXmlToSphinx::handleSnippetTag(QXmlStreamReader& reader)
         m_output << '\n';
     }
 }
+
 void QtXmlToSphinx::handleDotsTag(QXmlStreamReader& reader)
 {
     QXmlStreamReader::TokenType token = reader.tokenType();
@@ -916,11 +1003,11 @@ void QtXmlToSphinx::handleTableTag(QXmlStreamReader& reader)
     if (token == QXmlStreamReader::StartElement) {
         if (parentTag() == WebXmlTag::para)
             handleParaTagEnd(); // End <para> to prevent the table from being rst-escaped
-        m_currentTable.clear();
+        m_tables.push({});
     } else if (token == QXmlStreamReader::EndElement) {
         // write the table on m_output
         formatCurrentTable();
-        m_currentTable.clear();
+        m_tables.pop();
         if (parentTag() == WebXmlTag::para)
             handleParaTagStart();
     }
@@ -936,7 +1023,7 @@ void QtXmlToSphinx::handleTermTag(QXmlStreamReader& reader)
     } else if (token == QXmlStreamReader::EndElement) {
         TableCell cell;
         cell.data = popOutputBuffer().trimmed();
-        m_currentTable.appendRow(TableRow(1, cell));
+        m_tables.back().appendRow(TableRow(1, cell));
     }
 }
 
@@ -945,18 +1032,20 @@ void QtXmlToSphinx::handleItemTag(QXmlStreamReader& reader)
 {
     QXmlStreamReader::TokenType token = reader.tokenType();
     if (token == QXmlStreamReader::StartElement) {
-        if (m_currentTable.isEmpty())
-            m_currentTable.appendRow({});
-        TableRow& row = m_currentTable.last();
+        auto &table = m_tables.back();
+        if (table.isEmpty())
+            table.appendRow({});
+        TableRow& row = table.last();
         TableCell cell;
         cell.colSpan = reader.attributes().value(u"colspan"_s).toShort();
         cell.rowSpan = reader.attributes().value(u"rowspan"_s).toShort();
         row << cell;
         pushOutputBuffer();
     } else if (token == QXmlStreamReader::EndElement) {
-        QString data = popOutputBuffer().trimmed();
-        if (!m_currentTable.isEmpty()) {
-            TableRow& row = m_currentTable.last();
+        QString data = trimLeadingNewlines(trimRight(popOutputBuffer()));
+        auto &table = m_tables.back();
+        if (!table.isEmpty()) {
+            TableRow& row = table.last();
             if (!row.isEmpty())
                 row.last().data = data;
         }
@@ -969,15 +1058,16 @@ void QtXmlToSphinx::handleHeaderTag(QXmlStreamReader &reader)
     // C++ header with "name"/"href" attributes.
     if (reader.tokenType() == QXmlStreamReader::StartElement
         && !reader.attributes().hasAttribute(u"name"_s)) {
-        m_currentTable.setHeaderEnabled(true);
-        m_currentTable.appendRow({});
+        auto &table = m_tables.back();
+        table.setHeaderEnabled(true);
+        table.appendRow({});
     }
 }
 
 void QtXmlToSphinx::handleRowTag(QXmlStreamReader& reader)
 {
     if (reader.tokenType() == QXmlStreamReader::StartElement)
-        m_currentTable.appendRow({});
+        m_tables.back().appendRow({});
 }
 
 enum ListType { BulletList, OrderedList, EnumeratedList };
@@ -993,27 +1083,29 @@ static inline ListType webXmlListType(QStringView t)
 
 void QtXmlToSphinx::handleListTag(QXmlStreamReader& reader)
 {
-    // BUG We do not support a list inside a table cell
     static ListType listType = BulletList;
     QXmlStreamReader::TokenType token = reader.tokenType();
     if (token == QXmlStreamReader::StartElement) {
+        m_tables.push({});
+        auto &table = m_tables.back();
         listType = webXmlListType(reader.attributes().value(u"type"_s));
         if (listType == EnumeratedList) {
-            m_currentTable.appendRow(TableRow{TableCell(u"Constant"_s),
-                                              TableCell(u"Description"_s)});
-            m_currentTable.setHeaderEnabled(true);
+            table.appendRow(TableRow{TableCell(u"Constant"_s),
+                                     TableCell(u"Description"_s)});
+            table.setHeaderEnabled(true);
         }
         m_output.indent();
     } else if (token == QXmlStreamReader::EndElement) {
         m_output.outdent();
-        if (!m_currentTable.isEmpty()) {
+        const auto &table = m_tables.back();
+        if (!table.isEmpty()) {
             switch (listType) {
             case BulletList:
             case OrderedList: {
                 m_output << '\n';
                 const char *separator = listType == BulletList ? "* " : "#. ";
                 const char *indentLine = listType == BulletList ? "  " : "   ";
-                for (const TableCell &cell : m_currentTable.constFirst()) {
+                for (const TableCell &cell : table.constFirst()) {
                     const auto itemLines = QStringView{cell.data}.split(u'\n');
                     m_output << separator << itemLines.constFirst() << '\n';
                     for (qsizetype i = 1, max = itemLines.size(); i < max; ++i)
@@ -1027,7 +1119,7 @@ void QtXmlToSphinx::handleListTag(QXmlStreamReader& reader)
                 break;
             }
         }
-        m_currentTable.clear();
+        m_tables.pop();
     }
 }
 
@@ -1069,7 +1161,7 @@ QtXmlToSphinxLink *QtXmlToSphinx::handleLinkStart(const QString &type, QString r
 
     if (type == u"external" || isHttpLink(ref)) {
         result->type = QtXmlToSphinxLink::External;
-    } else if (type == functionLinkType() && !m_context.isEmpty()) {
+    } else if (type == functionLinkType && !m_context.isEmpty()) {
         result->type = QtXmlToSphinxLink::Method;
         const auto rawlinklist = QStringView{result->linkRef}.split(u'.');
         if (rawlinklist.size() == 1 || rawlinklist.constFirst() == m_context) {
@@ -1080,9 +1172,9 @@ QtXmlToSphinxLink *QtXmlToSphinx::handleLinkStart(const QString &type, QString r
         } else {
             result->linkRef = m_generator->expandFunction(result->linkRef);
         }
-    } else if (type == functionLinkType() && m_context.isEmpty()) {
+    } else if (type == functionLinkType && m_context.isEmpty()) {
         result->type = QtXmlToSphinxLink::Function;
-    } else if (type == classLinkType()) {
+    } else if (type == classLinkType) {
         result->type = QtXmlToSphinxLink::Class;
         result->linkRef = m_generator->expandClass(m_context, result->linkRef);
     } else if (type == u"enum") {
@@ -1122,10 +1214,10 @@ static QString fixLinkText(const QtXmlToSphinxLink *linkContext,
     else
          QtXmlToSphinx::stripPythonQualifiers(&linktext);
     if (linkContext->linkRef == linktext)
-        return QString();
+         return {};
     if ((linkContext->type & QtXmlToSphinxLink::FunctionMask) != 0
         && (linkContext->linkRef + u"()"_s) == linktext) {
-        return QString();
+        return {};
     }
     return  linktext;
 }
@@ -1148,36 +1240,17 @@ WebXmlTag QtXmlToSphinx::parentTag() const
 
 // Copy images that are placed in a subdirectory "images" under the webxml files
 // by qdoc to a matching subdirectory under the "rst/PySide6/<module>" directory
-static bool copyImage(const QString &href, const QString &docDataDir,
-                      const QString &context, const QString &outputDir,
+static bool copyImage(const QString &docDataDir, const QString &relativeSourceFile,
+                      const QString &outputDir, const QString &relativeTargetFile,
                       const QLoggingCategory &lc, QString *errorMessage)
 {
-    const QChar slash = u'/';
-    const int lastSlash = href.lastIndexOf(slash);
-    const QString imagePath = lastSlash != -1 ? href.left(lastSlash) : QString();
-    const QString imageFileName = lastSlash != -1 ? href.right(href.size() - lastSlash - 1) : href;
-    QFileInfo imageSource(docDataDir + slash + href);
-    if (!imageSource.exists()) {
-        QTextStream(errorMessage) << "Image " << href << " does not exist in "
-            << QDir::toNativeSeparators(docDataDir);
-        return false;
-    }
-    // Determine directory from context, "Pyside2.QtGui.QPainter" ->"Pyside2/QtGui".
-    // FIXME: Not perfect yet, should have knowledge about namespaces (DataVis3D) or
-    // nested classes "Pyside2.QtGui.QTouchEvent.QTouchPoint".
-    QString relativeTargetDir = context;
-    const int lastDot = relativeTargetDir.lastIndexOf(u'.');
-    if (lastDot != -1)
-        relativeTargetDir.truncate(lastDot);
-    relativeTargetDir.replace(u'.', slash);
-    if (!imagePath.isEmpty())
-        relativeTargetDir += slash + imagePath;
-
-    const QString targetDir = outputDir + slash + relativeTargetDir;
-    const QString targetFileName = targetDir + slash + imageFileName;
+    QString targetFileName = outputDir + u'/' + relativeTargetFile;
     if (QFileInfo::exists(targetFileName))
         return true;
-    if (!QFileInfo::exists(targetDir)) {
+
+    QString relativeTargetDir = relativeTargetFile;
+    relativeTargetDir.truncate(qMax(relativeTargetDir.lastIndexOf(u'/'), qsizetype(0)));
+    if (!relativeTargetDir.isEmpty() && !QFileInfo::exists(outputDir + u'/' + relativeTargetDir)) {
         const QDir outDir(outputDir);
         if (!outDir.mkpath(relativeTargetDir)) {
             QTextStream(errorMessage) << "Cannot create " << QDir::toNativeSeparators(relativeTargetDir)
@@ -1186,28 +1259,29 @@ static bool copyImage(const QString &href, const QString &docDataDir,
         }
     }
 
-    QFile source(imageSource.absoluteFilePath());
+    QFile source(docDataDir + u'/' + relativeSourceFile);
     if (!source.copy(targetFileName)) {
         QTextStream(errorMessage) << "Cannot copy " << QDir::toNativeSeparators(source.fileName())
             << " to " << QDir::toNativeSeparators(targetFileName) << ": "
             << source.errorString();
         return false;
     }
-    qCDebug(lc).noquote().nospace() << __FUNCTION__ << " href=\""
-        << href << "\", context=\"" << context << "\", docDataDir=\""
-        << docDataDir << "\", outputDir=\"" << outputDir << "\", copied \""
-        << source.fileName() << "\"->\"" << targetFileName << '"';
+
+    qCDebug(lc).noquote().nospace() << __FUNCTION__ << " \"" << relativeSourceFile
+        << "\"->\"" << relativeTargetFile << '"';
     return true;
 }
 
 bool QtXmlToSphinx::copyImage(const QString &href) const
 {
     QString errorMessage;
-    const bool result =
-        ::copyImage(href, m_parameters.docDataDir, m_context,
-                    m_parameters.outputDirectory,
-                    m_generator->loggingCategory(),
-                    &errorMessage);
+    const auto imagePaths = m_generator->resolveImage(href, m_context);
+    const bool result = ::copyImage(m_parameters.docDataDir,
+                                    imagePaths.source,
+                                    m_parameters.outputDirectory,
+                                    imagePaths.target,
+                                    m_generator->loggingCategory(),
+                                    &errorMessage);
     if (!result)
         throw Exception(errorMessage);
     return result;
@@ -1233,7 +1307,7 @@ void QtXmlToSphinx::handleInlineImageTag(QXmlStreamReader& reader)
     // enclosed by '|' and define it further down. Determine tag from the base
     //file name with number.
     QString tag = href;
-    int pos = tag.lastIndexOf(u'/');
+    auto pos = tag.lastIndexOf(u'/');
     if (pos != -1)
         tag.remove(0, pos + 1);
     pos = tag.indexOf(u'.');
@@ -1301,11 +1375,11 @@ void QtXmlToSphinx::handlePageTag(QXmlStreamReader &reader)
 
     m_output << disableIndent;
 
-    const auto  title = reader.attributes().value(titleAttribute());
+    const auto  title = reader.attributes().value("title");
     if (!title.isEmpty())
         m_output << rstLabel(title.toString());
 
-    const auto  fullTitle = reader.attributes().value(fullTitleAttribute());
+    const auto  fullTitle = reader.attributes().value("fulltitle");
     const int size = fullTitle.isEmpty()
        ? writeEscapedRstText(m_output, title)
        : writeEscapedRstText(m_output, fullTitle);
@@ -1318,7 +1392,7 @@ void QtXmlToSphinx::handleTargetTag(QXmlStreamReader &reader)
 {
     if (reader.tokenType() != QXmlStreamReader::StartElement)
         return;
-    const auto  name = reader.attributes().value(nameAttribute());
+    const auto  name = reader.attributes().value("name");
     if (!name.isEmpty())
         m_output << rstLabel(name.toString());
 }
@@ -1493,13 +1567,11 @@ void QtXmlToSphinx::Table::format(TextStream& s) const
         // print line
         s << '+';
         for (qsizetype col = 0; col < headerColumnCount; ++col) {
-            char c;
+            char c = '-';
             if (col >= row.size() || row[col].rowSpan == -1)
                 c = ' ';
             else if (i == 1 && hasHeader())
                 c = '=';
-            else
-                c = '-';
             s << Pad(c, colWidths.at(col)) << '+';
         }
         s << '\n';
diff --git a/sources/shiboken6/generator/qtdoc/qtxmltosphinx.h b/sources/shiboken6/generator/qtdoc/qtxmltosphinx.h
index e3efde412..398c5bc97 100644
--- a/sources/shiboken6/generator/qtdoc/qtxmltosphinx.h
+++ b/sources/shiboken6/generator/qtdoc/qtxmltosphinx.h
@@ -8,9 +8,10 @@
 
 #include <QtCore/QList>
 #include <QtCore/QScopedPointer>
-#include <QtCore/QSharedPointer>
 #include <QtCore/QStack>
 
+#include <memory>
+
 QT_BEGIN_NAMESPACE
 class QDebug;
 class QXmlStreamReader;
@@ -69,14 +70,9 @@ public:
                 return m_normalized;
             }
 
-            void clear() {
-                m_normalized = false;
-                m_rows.clear();
-            }
-
             void appendRow(const TableRow &row) { m_rows.append(row); }
 
-            const TableRow &constFirst() { return m_rows.constFirst(); }
+            const TableRow &constFirst() const { return m_rows.constFirst(); }
             TableRow &first() { return m_rows.first(); }
             TableRow &last() { return m_rows.last(); }
 
@@ -105,8 +101,12 @@ public:
 
     static void stripPythonQualifiers(QString *s);
 
+    // For testing
+    static QString readSnippet(QIODevice &inputFile, const QString &identifier,
+                               QString *errorMessage);
+
 private:
-    using StringSharedPtr = QSharedPointer<QString>;
+    using StringSharedPtr = std::shared_ptr<QString>;
 
     QString transform(const QString& doc);
 
@@ -160,7 +160,7 @@ private:
 
     QStack<StringSharedPtr> m_buffers; // Maintain address stability since it used in TextStream
 
-    Table m_currentTable;
+    QStack<Table> m_tables; // Stack of tables, used for <table><list> with nested <item>
     QScopedPointer<QtXmlToSphinxLink> m_linkContext; // for <link>
     QScopedPointer<QtXmlToSphinxLink> m_seeAlsoContext; // for <see-also>foo()</see-also>
     QString m_context;
@@ -173,6 +173,8 @@ private:
     QString m_opened_anchor;
     QList<InlineImage> m_inlineImages;
 
+    bool m_containsAutoTranslations = false;
+
     struct Snippet
     {
         enum Result {
@@ -186,10 +188,12 @@ private:
         Result result;
     };
 
+    void setAutoTranslatedNote(QString *str) const;
+
     Snippet readSnippetFromLocations(const QString &path,
                                      const QString &identifier,
                                      const QString &fallbackPath,
-                                     QString *errorMessage) const;
+                                     QString *errorMessage);
     static QString readFromLocation(const QString &location, const QString &identifier,
                              QString *errorMessage);
     void pushOutputBuffer();
diff --git a/sources/shiboken6/generator/qtdoc/qtxmltosphinxinterface.h b/sources/shiboken6/generator/qtdoc/qtxmltosphinxinterface.h
index 16eefad83..d4a098a12 100644
--- a/sources/shiboken6/generator/qtdoc/qtxmltosphinxinterface.h
+++ b/sources/shiboken6/generator/qtdoc/qtxmltosphinxinterface.h
@@ -53,6 +53,15 @@ public:
 
     virtual QtXmlToSphinxLink resolveLink(const QtXmlToSphinxLink &) const = 0;
 
+    // Resolve images paths relative to doc data directory/output directory.
+    struct Image
+    {
+        QString source;
+        QString target;
+    };
+
+    virtual Image resolveImage(const QString &href, const QString &context) const = 0;
+
     virtual ~QtXmlToSphinxDocGeneratorInterface() = default;
 };
 
diff --git a/sources/shiboken6/generator/qtdoc/rstformat.h b/sources/shiboken6/generator/qtdoc/rstformat.h
index 6e97c5fcd..8af7671fb 100644
--- a/sources/shiboken6/generator/qtdoc/rstformat.h
+++ b/sources/shiboken6/generator/qtdoc/rstformat.h
@@ -30,28 +30,6 @@ inline QByteArray rstDeprecationNote(const char *what)
         + what + QByteArrayLiteral(" is deprecated.\n\n");
 }
 
-class Pad
-{
-public:
-    explicit Pad(char c, int count) : m_char(c), m_count(count) {}
-
-    void write(TextStream &str) const
-    {
-        for (int i = 0; i < m_count; ++i)
-            str << m_char;
-    }
-
-private:
-    const char m_char;
-    const int m_count;
-};
-
-inline TextStream &operator<<(TextStream &str, const Pad &pad)
-{
-    pad.write(str);
-    return str;
-}
-
 template <class String>
 inline int writeEscapedRstText(TextStream &str, const String &s)
 {
diff --git a/sources/shiboken6/generator/shiboken/configurablescope.h b/sources/shiboken6/generator/shiboken/configurablescope.h
new file mode 100644
index 000000000..9040c7ad9
--- /dev/null
+++ b/sources/shiboken6/generator/shiboken/configurablescope.h
@@ -0,0 +1,33 @@
+// 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 CONFIGURABLESCOPE_H
+#define CONFIGURABLESCOPE_H
+
+#include <textstream.h>
+#include <configurabletypeentry.h>
+
+/// Enclose a scope within preprocessor conditions for configurable entries
+class ConfigurableScope
+{
+public:
+    explicit ConfigurableScope(TextStream &s, const ConfigurableTypeEntryCPtr &t) :
+        m_stream(s),
+        m_hasConfigCondition(t->hasConfigCondition())
+    {
+        if (m_hasConfigCondition)
+            m_stream << t->configCondition() << '\n';
+    }
+
+    ~ConfigurableScope()
+    {
+        if (m_hasConfigCondition)
+            m_stream << "#endif\n";
+    }
+
+private:
+    TextStream &m_stream;
+    const bool m_hasConfigCondition;
+};
+
+#endif // CONFIGURABLESCOPE_H
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
index 47fb271f9..97a38a08d 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "cppgenerator.h"
+#include "configurablescope.h"
 #include "generatorargument.h"
+#include "generatorstrings.h"
 #include "defaultvalue.h"
 #include "generatorcontext.h"
 #include "codesnip.h"
@@ -50,14 +52,30 @@
 #include <algorithm>
 #include <cstring>
 #include <memory>
+#include <set>
 
 using namespace Qt::StringLiterals;
 
+static const char shibokenErrorsOccurred[] = "Shiboken::Errors::occurred() != nullptr";
+
+static constexpr auto virtualMethodStaticReturnVar = "result"_L1;
+static constexpr auto initFuncPrefix = "init_"_L1;
+
+static constexpr auto sbkObjectTypeF = "SbkObject_TypeF()"_L1;
+static const char initInheritanceFunction[] = "initInheritance";
+
+static QString mangleName(QString name)
+{
+    if (name == u"None" || name == u"False" || name == u"True" || name == u"from")
+        name += u'_';
+    return name;
+}
+
 struct sbkUnusedVariableCast
 {
-    explicit sbkUnusedVariableCast(QString name) : m_name(name) {}
+    explicit sbkUnusedVariableCast(QAnyStringView name) : m_name(name) {}
 
-    const QString m_name;
+    const QAnyStringView m_name;
 };
 
 TextStream &operator<<(TextStream &str, const sbkUnusedVariableCast &c)
@@ -66,36 +84,23 @@ TextStream &operator<<(TextStream &str, const sbkUnusedVariableCast &c)
     return str;
 }
 
-static const QString CPP_ARG0 = u"cppArg0"_s;
-static const char methodDefSentinel[] = "{nullptr, nullptr, 0, nullptr} // Sentinel\n";
-const char *CppGenerator::PYTHON_TO_CPPCONVERSION_STRUCT = "Shiboken::Conversions::PythonToCppConversion";
+struct pyTypeGetSlot
+{
+    explicit pyTypeGetSlot(QAnyStringView funcType, QAnyStringView typeObject,
+                           QAnyStringView aSlot) :
+        m_funcType(funcType), m_typeObject(typeObject), m_slot(aSlot) {}
 
-static inline QString reprFunction() { return QStringLiteral("__repr__"); }
+    const QAnyStringView m_funcType;
+    const QAnyStringView m_typeObject;
+    const QAnyStringView m_slot;
+};
 
-static const char typeNameFunc[] = R"CPP(template <class T>
-static const char *typeNameOf(const T &t)
+TextStream &operator<<(TextStream &str, const pyTypeGetSlot &p)
 {
-    const char *typeName =  typeid(t).name();
-    auto size = std::strlen(typeName);
-#if defined(Q_CC_MSVC) // MSVC: "class QPaintDevice * __ptr64"
-    if (auto lastStar = strchr(typeName, '*')) {
-        // MSVC: "class QPaintDevice * __ptr64"
-        while (*--lastStar == ' ') {
-        }
-        size = lastStar - typeName + 1;
-    }
-#else // g++, Clang: "QPaintDevice *" -> "P12QPaintDevice"
-    if (size > 2 && typeName[0] == 'P' && std::isdigit(typeName[1])) {
-        ++typeName;
-        --size;
-    }
-#endif
-    char *result = new char[size + 1];
-    result[size] = '\0';
-    memcpy(result, typeName, size);
-    return result;
+    str << "reinterpret_cast<" << p.m_funcType << ">(PepType_GetSlot("
+        << p.m_typeObject << ", " << p.m_slot << "));\n";
+    return str;
 }
-)CPP";
 
 TextStream &operator<<(TextStream &s, CppGenerator::ErrorReturn r)
 {
@@ -117,6 +122,25 @@ TextStream &operator<<(TextStream &s, CppGenerator::ErrorReturn r)
     return s;
 }
 
+static constexpr auto converterVar = "converter"_L1;
+
+struct registerConverterName
+{
+    explicit registerConverterName(QAnyStringView typeName,
+                                   QAnyStringView varName = converterVar) :
+        m_typeName(typeName), m_varName(varName) {}
+
+    QAnyStringView m_typeName;
+    QAnyStringView m_varName;
+};
+
+TextStream &operator<<(TextStream &s, const registerConverterName &r)
+{
+    s << "Shiboken::Conversions::registerConverterName(" << r.m_varName
+        <<  ", \"" << r.m_typeName << "\");\n";
+    return s;
+}
+
 // Protocol function name / function parameters / return type
 struct ProtocolEntry
 {
@@ -149,7 +173,7 @@ const ProtocolEntries &mappingProtocols()
          u"PyObject*"_s},
         {u"__msetitem__"_s,
          u"PyObject *self, PyObject *_key, PyObject *_value"_s,
-         intT()}};
+         intT}};
     return result;
 }
 
@@ -166,16 +190,16 @@ const ProtocolEntries &sequenceProtocols()
          u"PyObject*"_s},
         {u"__setitem__"_s,
          u"PyObject *self, Py_ssize_t _i, PyObject *_value"_s,
-         intT()},
+         intT},
         {u"__getslice__"_s,
          u"PyObject *self, Py_ssize_t _i1, Py_ssize_t _i2"_s,
          u"PyObject*"_s},
         {u"__setslice__"_s,
          u"PyObject *self, Py_ssize_t _i1, Py_ssize_t _i2, PyObject *_value"_s,
-         intT()},
+         intT},
         {u"__contains__"_s,
          u"PyObject *self, PyObject *_value"_s,
-         intT()},
+         intT},
         {u"__concat__"_s,
          u"PyObject *self, PyObject *_other"_s,
          u"PyObject*"_s}
@@ -187,13 +211,13 @@ const ProtocolEntries &sequenceProtocols()
 static QString opaqueContainerCreationFunc(const AbstractMetaType &type)
 {
     const auto containerTypeEntry =
-        qSharedPointerCast<const ContainerTypeEntry>(type.typeEntry());
+        std::static_pointer_cast<const ContainerTypeEntry>(type.typeEntry());
     const auto instantiationTypeEntry =
         type.instantiations().constFirst().typeEntry();
     QString result = u"create"_s;
     if (type.isConstant())
         result += u"Const"_s;
-    result += containerTypeEntry->opaqueContainerName(instantiationTypeEntry->name());
+    result += containerTypeEntry->opaqueContainerName(type.instantiationCppSignatures());
     return result;
 }
 
@@ -213,135 +237,16 @@ QString CppGenerator::fileNameForContext(const GeneratorContext &context) const
     return fileNameForContextHelper(context, u"_wrapper.cpp"_s);
 }
 
-static bool isInplaceAdd(const AbstractMetaFunctionCPtr &func)
-{
-    return func->name() == u"operator+=";
-}
-
-static bool isIncrementOperator(const AbstractMetaFunctionCPtr &func)
-{
-    return func->functionType() == AbstractMetaFunction::IncrementOperator;
-}
-
-static bool isDecrementOperator(const AbstractMetaFunctionCPtr &func)
-{
-    return func->functionType() == AbstractMetaFunction::DecrementOperator;
-}
-
-// Filter predicate for operator functions
-static bool skipOperatorFunc(const AbstractMetaFunctionCPtr &func)
-{
-    if (func->isModifiedRemoved() || func->usesRValueReferences())
-        return true;
-    const auto &name = func->name();
-    return name == u"operator[]" || name == u"operator->" || name == u"operator!";
-}
-
-QList<AbstractMetaFunctionCList>
-    CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass *metaClass,
-                                                 OperatorQueryOptions query)
-{
-    // ( func_name, num_args ) => func_list
-    QMap<QPair<QString, int>, AbstractMetaFunctionCList> results;
-
-    auto funcs = metaClass->operatorOverloads(query);
-    auto end = std::remove_if(funcs.begin(), funcs.end(), skipOperatorFunc);
-    funcs.erase(end, funcs.end());
-
-    // If we have operator+=, we remove the operator++/-- which would
-    // otherwise be used for emulating __iadd__, __isub__.
-    if (std::any_of(funcs.cbegin(), funcs.cend(), isInplaceAdd)) {
-        end = std::remove_if(funcs.begin(), funcs.end(),
-                             [] (const AbstractMetaFunctionCPtr &func) {
-                                 return func->isIncDecrementOperator();
-                             });
-        funcs.erase(end, funcs.end());
-    } else {
-        // If both prefix/postfix ++/-- are present, remove one
-        if (std::count_if(funcs.begin(), funcs.end(), isIncrementOperator) > 1)
-            funcs.erase(std::find_if(funcs.begin(), funcs.end(), isIncrementOperator));
-        if (std::count_if(funcs.begin(), funcs.end(), isDecrementOperator) > 1)
-            funcs.erase(std::find_if(funcs.begin(), funcs.end(), isDecrementOperator));
-    }
-
-    for (const auto &func : funcs) {
-        int args;
-        if (func->isComparisonOperator()) {
-            args = -1;
-        } else {
-            args = func->arguments().size();
-        }
-        QPair<QString, int > op(func->name(), args);
-        results[op].append(func);
-    }
-    QList<AbstractMetaFunctionCList> result;
-    result.reserve(results.size());
-    for (auto it = results.cbegin(), end = results.cend(); it != end; ++it)
-        result.append(it.value());
-    return result;
-}
-
-CppGenerator::BoolCastFunctionOptional
-    CppGenerator::boolCast(const AbstractMetaClass *metaClass) const
-{
-    const auto te = metaClass->typeEntry();
-    if (te->isSmartPointer()) {
-        auto ste = qSharedPointerCast<const SmartPointerTypeEntry>(te);
-
-        auto valueCheckMethod = ste->valueCheckMethod();
-        if (!valueCheckMethod.isEmpty()) {
-            const auto func = metaClass->findFunction(valueCheckMethod);
-            if (func.isNull())
-                throw Exception(msgMethodNotFound(metaClass, valueCheckMethod));
-            return BoolCastFunction{func, false};
-        }
-
-        auto nullCheckMethod = ste->nullCheckMethod();
-        if (!nullCheckMethod.isEmpty()) {
-            const auto func = metaClass->findFunction(nullCheckMethod);
-            if (func.isNull())
-                throw Exception(msgMethodNotFound(metaClass, nullCheckMethod));
-            return BoolCastFunction{func, true};
-        }
-    }
-
-    auto mode = te->operatorBoolMode();
-    if (useOperatorBoolAsNbNonZero()
-        ? mode != TypeSystem::BoolCast::Disabled : mode == TypeSystem::BoolCast::Enabled) {
-        const auto func = metaClass->findOperatorBool();
-        if (!func.isNull())
-            return BoolCastFunction{func, false};
-    }
-
-    mode = te->isNullMode();
-    if (useIsNullAsNbNonZero()
-        ? mode != TypeSystem::BoolCast::Disabled : mode == TypeSystem::BoolCast::Enabled) {
-        const auto func = metaClass->findQtIsNullMethod();
-        if (!func.isNull())
-            return BoolCastFunction{func, true};
-    }
-    return std::nullopt;
-}
-
-std::optional<AbstractMetaType>
-    CppGenerator::findSmartPointerInstantiation(const SmartPointerTypeEntryCPtr &pointer,
-                                                const TypeEntryCPtr &pointee) const
-{
-    for (const auto &smp : api().instantiatedSmartPointers()) {
-        const auto &i = smp.type;
-        if (i.typeEntry() == pointer && i.instantiations().at(0).typeEntry() == pointee)
-            return i;
-    }
-    return {};
-}
-
 void CppGenerator::clearTpFuncs()
 {
+    // Functions that should not be registered under a name in PyMethodDef,
+    // but under a special constant under slots.
     m_tpFuncs = {
         {u"__str__"_s, {}}, {u"__str__"_s, {}},
-        {reprFunction(), {}}, {u"__iter__"_s, {}},
+        {REPR_FUNCTION, {}}, {u"__iter__"_s, {}},
         {u"__next__"_s, {}}
     };
+    m_nbFuncs = { {u"__abs__"_s, {}}, {u"__pow__"_s, {} }};
 }
 
 // Prevent ELF symbol qt_version_tag from being generated into the source
@@ -351,7 +256,7 @@ static const char includeQDebug[] =
 "#endif\n"
 "#include <QtCore/QDebug>\n";
 
-static QString chopType(QString s)
+QString CppGenerator::chopType(QString s)
 {
     if (s.endsWith(u"_Type"))
         s.chop(5);
@@ -463,11 +368,7 @@ static QSet<QString> useIntSet()
 
 static bool _shouldInheritInt(const AbstractMetaEnum &cppEnum)
 {
-    if (!cppEnum.fullName().startsWith(u"PySide6."_s))
-        return true;
-    // static auto intSet = useIntSet();
-    // return intSet.contains(cppEnum.fullName());
-    return false;
+    return !cppEnum.fullName().startsWith(u"PySide6."_s);
 }
 
 static QString BuildEnumFlagInfo(const AbstractMetaEnum &cppEnum)
@@ -495,15 +396,15 @@ static QString BuildEnumFlagInfo(const AbstractMetaEnum &cppEnum)
 static void writePyGetSetDefEntry(TextStream &s, const QString &name,
                                   const QString &getFunc, const QString &setFunc)
 {
-    s << "{const_cast<char *>(\"" << name << "\"), " << getFunc << ", "
+    s << "{const_cast<char *>(\"" << mangleName(name) << "\"), " << getFunc << ", "
         << (setFunc.isEmpty() ? NULL_PTR : setFunc) << ", nullptr, nullptr},\n";
 }
 
 static bool generateRichComparison(const GeneratorContext &c)
 {
-    auto *metaClass = c.metaClass();
+    const auto metaClass = c.metaClass();
     if (c.forSmartPointer()) {
-        auto te = qSharedPointerCast<const SmartPointerTypeEntry>(metaClass->typeEntry());
+        auto te = std::static_pointer_cast<const SmartPointerTypeEntry>(metaClass->typeEntry());
         return te->smartPointerType() == TypeSystem::SmartPointerType::Shared;
     }
 
@@ -514,17 +415,16 @@ void CppGenerator::generateIncludes(TextStream &s, const GeneratorContext &class
                                     const IncludeGroupList &includes,
                                     const AbstractMetaClassCList &innerClasses) const
 {
-    const AbstractMetaClass *metaClass = classContext.metaClass();
+    const auto metaClass = classContext.metaClass();
 
     // write license comment
     s << licenseComment() << '\n';
 
     const bool normalClass = !classContext.forSmartPointer();
-    if (normalClass && !avoidProtectedHack() && !metaClass->isNamespace()
-        && !metaClass->hasPrivateDestructor()) {
-        s << "//workaround to access protected functions\n";
-        s << "#define protected public\n\n";
-    }
+    // Normally only required for classes for which we want to generate protected API,
+    // but it needs to be generated into all files to ensure ODR for Unity builds.
+    if (!avoidProtectedHack())
+        s << HeaderGenerator::protectedHackDefine;
 
     QByteArrayList cppIncludes{"typeinfo", "iterator", // for containers
                                "cctype", "cstring"};
@@ -540,7 +440,7 @@ void CppGenerator::generateIncludes(TextStream &s, const GeneratorContext &class
         s << includeQDebug;
         if (metaClass->hasToStringCapability())
             s << "#include <QtCore/QBuffer>\n";
-        if (metaClass->isQObject()) {
+        if (isQObject(metaClass)) {
             s << "#include <pysideqobject.h>\n"
                 << "#include <pysidesignal.h>\n"
                 << "#include <pysideproperty.h>\n"
@@ -548,7 +448,6 @@ void CppGenerator::generateIncludes(TextStream &s, const GeneratorContext &class
                 << "#include <pysidemetafunction.h>\n";
         }
         s << "#include <pysideqenum.h>\n"
-            << "#include <pysideqflags.h>\n"
             << "#include <pysideqmetatype.h>\n"
             << "#include <pysideutils.h>\n"
             << "#include <feature_select.h>\n"
@@ -571,13 +470,16 @@ void CppGenerator::generateIncludes(TextStream &s, const GeneratorContext &class
 
     if (!innerClasses.isEmpty()) {
         s  << "\n// inner classes\n";
-        for (const AbstractMetaClass *innerClass : innerClasses) {
+        for (const auto &innerClass : innerClasses) {
             GeneratorContext innerClassContext = contextForClass(innerClass);
             s << "#include \""
                 << HeaderGenerator::headerFileNameForContext(innerClassContext) << "\"\n";
         }
     }
 
+    if (avoidProtectedHack())
+        s << baseWrapperIncludes(classContext);
+
     for (const auto &g : includes)
         s << g;
 
@@ -588,35 +490,34 @@ void CppGenerator::generateIncludes(TextStream &s, const GeneratorContext &class
         s << "#include <" << i << ">\n";
 }
 
-static const char openTargetExternC[] =  R"(
-// Target ---------------------------------------------------------
-
-extern "C" {
-)";
-
-static const char closeExternC[] =  "} // extern \"C\"\n\n";
-
 // Write methods definition
-static void writePyMethodDefs(TextStream &s, const QString &className,
-                              const QString &methodsDefinitions, bool generateCopy)
+void CppGenerator::writePyMethodDefs(TextStream &s, const QString &className,
+                                     const QString &methodsDefinitions)
 {
     s << "static PyMethodDef " << className << "_methods[] = {\n" << indent
-        << methodsDefinitions << '\n';
-    if (generateCopy) {
-        s << "{\"__copy__\", reinterpret_cast<PyCFunction>(" << className << "___copy__)"
-          << ", METH_NOARGS, nullptr},\n";
+        << methodsDefinitions << METHOD_DEF_SENTINEL << outdent << "};\n\n";
+}
+
+void CppGenerator::writeModuleCodeSnips(TextStream &s, const CodeSnipList &codeSnips,
+                                        TypeSystem::CodeSnipPosition position,
+                                        TypeSystem::Language language) const
+{
+    if (!codeSnips.isEmpty()) {
+        try {
+            writeCodeSnips(s, codeSnips, position, language);
+        } catch (const std::exception &e) {
+            throw Exception(msgSnippetError("module source of "_L1 + moduleName(), e.what()));
+        }
     }
-    s  << methodDefSentinel << outdent
-        << "};\n\n";
 }
 
-static bool hasHashFunction(const AbstractMetaClass *c)
+bool CppGenerator::hasHashFunction(const AbstractMetaClassCPtr &c)
 {
     return !c->typeEntry()->hashFunction().isEmpty()
            || c->hasHashFunction();
 }
 
-static bool needsTypeDiscoveryFunction(const AbstractMetaClass *c)
+static bool needsTypeDiscoveryFunction(const AbstractMetaClassCPtr &c)
 {
     return c->baseClass() != nullptr
            && (c->isPolymorphic() || !c->typeEntry()->polymorphicIdValue().isEmpty());
@@ -646,7 +547,7 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
     }
 
     s.setLanguage(TextStream::Language::Cpp);
-    const AbstractMetaClass *metaClass = classContext.metaClass();
+    AbstractMetaClassCPtr metaClass = classContext.metaClass();
     const auto typeEntry = metaClass->typeEntry();
 
     auto innerClasses = metaClass->innerClasses();
@@ -671,10 +572,10 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
 
     // Use class base namespace
     {
-        const AbstractMetaClass *context = metaClass->enclosingClass();
+        AbstractMetaClassCPtr context = metaClass->enclosingClass();
         while (context) {
             if (context->isNamespace() && !context->enclosingClass()
-                && qSharedPointerCast<const NamespaceTypeEntry>(context->typeEntry())->generateUsing()) {
+                && std::static_pointer_cast<const NamespaceTypeEntry>(context->typeEntry())->generateUsing()) {
                 s << "\nusing namespace " << context->qualifiedCppName() << ";\n";
                 break;
             }
@@ -682,7 +583,7 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
         }
     }
 
-    s  << '\n' << typeNameFunc << '\n';
+    s  << '\n';
 
     // class inject-code native/beginning
     if (!typeEntry->codeSnips().isEmpty()) {
@@ -694,7 +595,7 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
 
     // python conversion rules
     if (typeEntry->isValue()) {
-        auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry);
+        auto vte = std::static_pointer_cast<const ValueTypeEntry>(typeEntry);
         if (vte->hasTargetConversionRule()) {
             s << "// Python Conversion\n";
             s << vte->targetConversionRule() << '\n';
@@ -721,13 +622,15 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
                 writeVirtualMethodNative(s, func, maxOverrides++);
         }
 
-        if (!avoidProtectedHack() || !metaClass->hasPrivateDestructor()) {
-            if (usePySideExtensions() && metaClass->isQObject())
-                writeMetaObjectMethod(s, classContext);
+        if (shouldGenerateMetaObjectFunctions(metaClass))
+            writeMetaObjectMethod(s, classContext);
+        if (!avoidProtectedHack() || !metaClass->hasPrivateDestructor())
             writeDestructorNative(s, classContext);
-        }
     }
 
+    for (const auto &f : metaClass->userAddedPythonOverrides())
+        writeUserAddedPythonOverride(s, f);
+
     StringStream smd(TextStream::Language::Cpp);
     StringStream md(TextStream::Language::Cpp);
     StringStream signatureStream(TextStream::Language::Cpp);
@@ -767,22 +670,22 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
                 smd << "static PyMethodDef " << methDefName << " = " << indent
                     << defEntries.constFirst() << outdent << ";\n\n";
             }
-            if (!m_tpFuncs.contains(rfunc->name()))
+            const auto &fname = rfunc->name();
+            if (!m_tpFuncs.contains(fname) && !m_nbFuncs.contains(fname))
                 md << defEntries;
         }
     }
     for (const auto &pyMethodDef : typeEntry->addedPyMethodDefEntrys())
         md << pyMethodDef << ",\n";
+
+    if (typeEntry->isValue())
+        writeCopyFunction(s, md, signatureStream, classContext);
+
     const QString methodsDefinitions = md.toString();
     const QString singleMethodDefinitions = smd.toString();
 
     const QString className = chopType(cpythonTypeName(metaClass));
 
-    if (typeEntry->isValue()) {
-        writeCopyFunction(s, classContext);
-        signatureStream << fullPythonClassName(metaClass) << ".__copy__()\n";
-    }
-
     // Write single method definitions
     s << singleMethodDefinitions;
 
@@ -818,7 +721,7 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
     }
 
     // Write methods definition
-    writePyMethodDefs(s, className, methodsDefinitions, typeEntry->isValue());
+    writePyMethodDefs(s, className, methodsDefinitions);
 
     // Write tp_s/getattro function
     const AttroCheck attroCheck = checkAttroFunctionNeeds(metaClass);
@@ -831,25 +734,8 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
         writeNbBoolFunction(classContext, f.value(), s);
 
     if (supportsNumberProtocol(metaClass)) {
-        const QList<AbstractMetaFunctionCList> opOverloads = filterGroupedOperatorFunctions(
-                metaClass,
-                OperatorQueryOption::ArithmeticOp
-                | OperatorQueryOption::IncDecrementOp
-                | OperatorQueryOption::LogicalOp
-                | OperatorQueryOption::BitwiseOp);
-
-        for (const AbstractMetaFunctionCList &allOverloads : opOverloads) {
-            AbstractMetaFunctionCList overloads;
-            for (const auto &func : allOverloads) {
-                if (!func->isModifiedRemoved()
-                    && !func->isPrivate()
-                    && (func->ownerClass() == func->implementingClass() || func->isAbstract()))
-                    overloads.append(func);
-            }
-
-            if (overloads.isEmpty())
-                continue;
-
+        const auto numberProtocolOps = numberProtocolOperators(metaClass);
+        for (const auto &overloads : numberProtocolOps) {
             OverloadData overloadData(overloads, api());
             writeMethodWrapper(s, overloadData, classContext);
             writeSignatureInfo(signatureStream, overloadData);
@@ -928,11 +814,10 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
     writeClassDefinition(s, metaClass, classContext);
     s << '\n';
 
-    if (needsTypeDiscoveryFunction(metaClass))
+    if (needsTypeDiscoveryFunction(metaClass)) {
         writeTypeDiscoveryFunction(s, metaClass);
-
-    writeFlagsNumberMethodsDefinitions(s, classEnums);
-    s << '\n';
+        s << '\n';
+    }
 
     writeConverterFunctions(s, metaClass, classContext);
     writeAddedTypeSignatures(signatureStream, typeEntry);
@@ -950,147 +835,6 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
     }
 }
 
-static bool hasParameterPredicate(const AbstractMetaFunctionCPtr &f)
-{
-    return !f->arguments().isEmpty();
-}
-
-void CppGenerator::generateSmartPointerClass(TextStream &s, const GeneratorContext &classContext)
-{
-    s.setLanguage(TextStream::Language::Cpp);
-    const AbstractMetaClass *metaClass = classContext.metaClass();
-    const auto typeEntry = qSharedPointerCast<const SmartPointerTypeEntry>(metaClass->typeEntry());
-    const bool hasPointeeClass = classContext.pointeeClass() != nullptr;
-    const auto smartPointerType = typeEntry->smartPointerType();
-    const bool isValueHandle = smartPointerType ==TypeSystem::SmartPointerType::ValueHandle;
-
-    IncludeGroup includes{u"Extra includes"_s, typeEntry->extraIncludes()};
-    if (hasPointeeClass)
-        includes.append(classContext.pointeeClass()->typeEntry()->include());
-    generateIncludes(s, classContext, {includes});
-
-    s  << '\n' << typeNameFunc << '\n';
-
-    // Create string literal for smart pointer getter method.
-    QString rawGetter = typeEntry->getter();
-    s << "static const char " << SMART_POINTER_GETTER << "[] = \"" << rawGetter << "\";";
-
-    // class inject-code native/beginning
-    if (!typeEntry->codeSnips().isEmpty()) {
-        writeClassCodeSnips(s, typeEntry->codeSnips(),
-                            TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode,
-                            classContext);
-        s << '\n';
-    }
-
-    StringStream smd(TextStream::Language::Cpp);
-    StringStream md(TextStream::Language::Cpp);
-    StringStream signatureStream(TextStream::Language::Cpp);
-
-    s << openTargetExternC;
-
-    const auto &functionGroups = getFunctionGroups(metaClass);
-
-    // Skip all public methods of the smart pointer except for the special
-    // methods declared in the type entry.
-
-    auto ctors = metaClass->queryFunctions(FunctionQueryOption::Constructors);
-    if (!hasPointeeClass && !isValueHandle) { // Cannot generate "int*"
-        auto end = std::remove_if(ctors.begin(), ctors.end(), hasParameterPredicate);
-        ctors.erase(end, ctors.end());
-    }
-
-    if (!ctors.isEmpty()) {
-        OverloadData overloadData(ctors, api());
-        writeConstructorWrapper(s, overloadData, classContext);
-        writeSignatureInfo(signatureStream, overloadData);
-    }
-
-    if (!typeEntry->resetMethod().isEmpty()) {
-        auto it = functionGroups.constFind(typeEntry->resetMethod());
-        if (it == functionGroups.cend())
-            throw Exception(msgCannotFindSmartPointerMethod(typeEntry, typeEntry->resetMethod()));
-        AbstractMetaFunctionCList resets = it.value();
-        if (!hasPointeeClass && !isValueHandle) { // Cannot generate "int*"
-            auto end = std::remove_if(resets.begin(), resets.end(), hasParameterPredicate);
-            resets.erase(end, resets.end());
-        }
-        if (!resets.isEmpty())
-            writeMethodWrapper(s, md, signatureStream, resets, classContext);
-    }
-
-    auto it = functionGroups.constFind(rawGetter);
-    if (it == functionGroups.cend() || it.value().size() != 1)
-        throw Exception(msgCannotFindSmartPointerGetter(typeEntry));
-
-    writeMethodWrapper(s, md, signatureStream, it.value(), classContext);
-
-    QStringList optionalMethods;
-    if (!typeEntry->refCountMethodName().isEmpty())
-        optionalMethods.append(typeEntry->refCountMethodName());
-    const QString valueCheckMethod = typeEntry->valueCheckMethod();
-    if (!valueCheckMethod.isEmpty() && !valueCheckMethod.startsWith(u"operator"))
-        optionalMethods.append(valueCheckMethod);
-    if (!typeEntry->nullCheckMethod().isEmpty())
-        optionalMethods.append(typeEntry->nullCheckMethod());
-
-    for (const QString &optionalMethod : optionalMethods) {
-        auto it = functionGroups.constFind(optionalMethod);
-        if (it == functionGroups.cend() || it.value().size() != 1)
-            throw Exception(msgCannotFindSmartPointerMethod(typeEntry, optionalMethod));
-        writeMethodWrapper(s, md, signatureStream, it.value(), classContext);
-    }
-
-    const QString methodsDefinitions = md.toString();
-    const QString singleMethodDefinitions = smd.toString();
-
-    const QString className = chopType(cpythonTypeName(typeEntry));
-
-    writeCopyFunction(s, classContext);
-    signatureStream << fullPythonClassName(metaClass) << ".__copy__()\n";
-
-    // Write single method definitions
-    s << singleMethodDefinitions;
-
-    // Write methods definition
-    writePyMethodDefs(s, className, methodsDefinitions, true /* ___copy__ */);
-
-    // Write tp_s/getattro function
-    const auto boolCastOpt = boolCast(metaClass);
-    writeSmartPointerGetattroFunction(s, classContext, boolCastOpt);
-    writeSmartPointerSetattroFunction(s, classContext);
-
-    if (boolCastOpt.has_value())
-        writeNbBoolFunction(classContext, boolCastOpt.value(), s);
-
-    if (smartPointerType == TypeSystem::SmartPointerType::Shared)
-        writeSmartPointerRichCompareFunction(s, classContext);
-
-    s << closeExternC;
-
-    if (hasHashFunction(metaClass))
-        writeHashFunction(s, classContext);
-
-    // Write tp_traverse and tp_clear functions.
-    writeTpTraverseFunction(s, metaClass);
-    writeTpClearFunction(s, metaClass);
-
-    writeClassDefinition(s, metaClass, classContext);
-
-    s << '\n';
-
-    writeConverterFunctions(s, metaClass, classContext);
-    writeClassRegister(s, metaClass, classContext, signatureStream);
-
-    // class inject-code native/end
-    if (!typeEntry->codeSnips().isEmpty()) {
-        writeClassCodeSnips(s, typeEntry->codeSnips(),
-                            TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode,
-                            classContext);
-        s << '\n';
-    }
-}
-
 void CppGenerator::writeMethodWrapper(TextStream &s, TextStream &definitionStream,
                                       TextStream &signatureStream,
                                       const AbstractMetaFunctionCList &overloads,
@@ -1132,7 +876,7 @@ void CppGenerator::writeConstructorNative(TextStream &s, const GeneratorContext
 }
 
 void CppGenerator::writeDestructorNative(TextStream &s,
-                                         const GeneratorContext &classContext) const
+                                         const GeneratorContext &classContext)
 {
     s << classContext.wrapperName() << "::~"
         << classContext.wrapperName() << "()\n{\n" << indent;
@@ -1157,9 +901,10 @@ QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctio
     // SbkType would return null when the type is a container.
     auto typeEntry = func->type().typeEntry();
     if (typeEntry->isContainer()) {
-        const auto cte = qSharedPointerCast<const ContainerTypeEntry>(typeEntry);
+        const auto cte = std::static_pointer_cast<const ContainerTypeEntry>(typeEntry);
         switch (cte->containerKind()) {
         case ContainerTypeEntry::ListContainer:
+        case ContainerTypeEntry::SpanContainer:
             break;
         case ContainerTypeEntry::SetContainer:
             return uR"("set")"_s;
@@ -1186,8 +931,8 @@ QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctio
     if (func->type().isPrimitive())
         return u'"' + func->type().name() + u'"';
 
-    return u"reinterpret_cast<PyTypeObject *>(Shiboken::SbkType< "_s
-        + typeEntry->qualifiedCppName() + u" >())->tp_name"_s;
+    return u"Shiboken::SbkType< "_s
+        + typeEntry->qualifiedCppName() + u" >()->tp_name"_s;
 }
 
 // When writing an overridden method of a wrapper class, write the part
@@ -1232,17 +977,24 @@ void CppGenerator::writeVirtualMethodCppCall(TextStream &s,
 }
 
 // Determine the return statement (void or a result value).
-QString CppGenerator::virtualMethodReturn(TextStream &s, const ApiExtractorResult &api,
-                                          const AbstractMetaFunctionCPtr &func,
-                                          const FunctionModificationList &functionModifications)
+
+CppGenerator::VirtualMethodReturn
+    CppGenerator::virtualMethodReturn(const ApiExtractorResult &api,
+                                      const AbstractMetaFunctionCPtr &func,
+                                      const FunctionModificationList &functionModifications)
 {
-    if (func->isVoid())
-        return u"return;"_s;
+    VirtualMethodReturn result;
+    if (func->isVoid()) {
+        result.statement = "return;"_L1;
+        return result;
+    }
+
+    result.statement = "return "_L1;
     const AbstractMetaType &returnType = func->type();
     for (const FunctionModification &mod : functionModifications) {
         for (const ArgumentModification &argMod : mod.argument_mods()) {
             if (argMod.index() == 0 && !argMod.replacedDefaultExpression().isEmpty()) {
-                static const QRegularExpression regex(QStringLiteral("%(\\d+)"));
+                static const QRegularExpression regex("%(\\d+)"_L1);
                 Q_ASSERT(regex.isValid());
                 QString expr = argMod.replacedDefaultExpression();
                 for (int offset = 0; ; ) {
@@ -1258,8 +1010,8 @@ QString CppGenerator::virtualMethodReturn(TextStream &s, const ApiExtractorResul
                     offset = match.capturedStart(1);
                 }
                 DefaultValue defaultReturnExpr(DefaultValue::Custom, expr);
-                return u"return "_s + defaultReturnExpr.returnValue()
-                       + u';';
+                result.statement += defaultReturnExpr.returnValue() + u';';
+                return result;
             }
         }
     }
@@ -1271,22 +1023,19 @@ QString CppGenerator::virtualMethodReturn(TextStream &s, const ApiExtractorResul
         errorMsg = msgCouldNotFindMinimalConstructor(errorMsg,
                                                      func->type().cppSignature(),
                                                      errorMessage);
-        qCWarning(lcShiboken).noquote().nospace() << errorMsg;
-        s  << "\n#error " << errorMsg << '\n';
+        throw Exception(errorMsg);
     }
-    if (returnType.referenceType() == LValueReference) {
-        s << "static " << returnType.typeEntry()->qualifiedCppName()
-            << " result;\n";
-        return u"return result;"_s;
-    }
-    return u"return "_s + defaultReturnExpr->returnValue()
-           + u';';
+
+    result.needsReference = returnType.referenceType() == LValueReference;
+    result.statement += (result.needsReference
+        ? virtualMethodStaticReturnVar : defaultReturnExpr->returnValue()) + u';';
+    return result;
 }
 
 // Create an argument for Py_BuildValue() when writing virtual methods.
 // Return a pair of (argument, format-char).
-QPair<QString, QChar> CppGenerator::virtualMethodNativeArg(const AbstractMetaFunctionCPtr &func,
-                                                             const AbstractMetaArgument &arg)
+std::pair<QString, QChar> CppGenerator::virtualMethodNativeArg(const AbstractMetaFunctionCPtr &func,
+                                                               const AbstractMetaArgument &arg)
 {
     if (func->hasConversionRule(TypeSystem::TargetLangCode, arg.argumentIndex() + 1))
         return {arg.name() + CONV_RULE_OUT_VAR_SUFFIX, u'N'};
@@ -1312,7 +1061,7 @@ static const char PYTHON_ARGS_ARRAY[] = "pyArgArray";
 void CppGenerator::writeVirtualMethodNativeVectorCallArgs(TextStream &s,
                                                           const AbstractMetaFunctionCPtr &func,
                                                           const AbstractMetaArgumentList &arguments,
-                                                          const QList<int> &invalidateArgs) const
+                                                          const QList<int> &invalidateArgs)
 {
     Q_ASSERT(!arguments.isEmpty());
     s << "PyObject *" << PYTHON_ARGS_ARRAY <<'[' << arguments.size() << "] = {\n" << indent;
@@ -1333,15 +1082,15 @@ void CppGenerator::writeVirtualMethodNativeVectorCallArgs(TextStream &s,
     if (!invalidateArgs.isEmpty())
         s << '\n';
     for (int index : invalidateArgs) {
-        s << "const bool invalidateArg" << index << " = " << PYTHON_ARGS_ARRAY <<
-          '[' << index - 1 << "]->ob_refcnt == 1;\n";
+        s << "const bool invalidateArg" << index << " = Py_REFCNT(" << PYTHON_ARGS_ARRAY <<
+          '[' << index - 1 << "]) == 1;\n";
     }
 }
 
 void CppGenerator::writeVirtualMethodNativeArgs(TextStream &s,
                                                 const AbstractMetaFunctionCPtr &func,
                                                 const AbstractMetaArgumentList &arguments,
-                                                const QList<int> &invalidateArgs) const
+                                                const QList<int> &invalidateArgs)
 {
     s << "Shiboken::AutoDecRef " << PYTHON_ARGS << '(';
     if (arguments.isEmpty()) {
@@ -1361,8 +1110,8 @@ void CppGenerator::writeVirtualMethodNativeArgs(TextStream &s,
         << indent << argConversions.join(u",\n"_s) << outdent << "\n));\n";
 
     for (int index : std::as_const(invalidateArgs)) {
-        s << "bool invalidateArg" << index << " = PyTuple_GET_ITEM(" << PYTHON_ARGS
-            << ", " << index - 1 << ")->ob_refcnt == 1;\n";
+        s << "bool invalidateArg" << index << " = Py_REFCNT(PyTuple_GET_ITEM(" << PYTHON_ARGS
+            << ", " << index - 1 << ")) == 1;\n";
     }
 }
 
@@ -1373,13 +1122,42 @@ static bool isArgumentNotRemoved(const AbstractMetaArgument &a)
 
 // PyObject_Vectorcall(): since 3.9
 static const char vectorCallCondition[] =
-    "#if !defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x03090000\n";
+    "#if !defined(PYPY_VERSION) && !defined(Py_LIMITED_API)\n";
 
 // PyObject_CallNoArgs(): since 3.9, stable API since 3.10
 static const char noArgsCallCondition[] =
-    "#if (defined(Py_LIMITED_API) && Py_LIMITED_API >= 0x030A0000) || (!defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x03090000)\n";
+    "#if !defined(PYPY_VERSION) && ((defined(Py_LIMITED_API) && Py_LIMITED_API >= 0x030A0000) || !defined(Py_LIMITED_API))\n";
 static const char inverseNoArgsCallCondition[] =
-    "#if (defined(Py_LIMITED_API) && Py_LIMITED_API < 0x030A0000) || (!defined(Py_LIMITED_API) && PY_VERSION_HEX < 0x03090000)\n";
+    "#if defined(PYPY_VERSION) || (defined(Py_LIMITED_API) && Py_LIMITED_API < 0x030A0000)\n";
+
+static inline void writeVirtualMethodStaticReturnVar(TextStream &s, const AbstractMetaFunctionCPtr &func)
+{
+    s << "static " << func->type().typeEntry()->qualifiedCppName() << ' '
+        << virtualMethodStaticReturnVar << ";\n";
+}
+
+static void writeFuncNameVar(TextStream &s, const AbstractMetaFunctionCPtr &func,
+                             const QString &funcName)
+{
+    // PYSIDE-1019: Add info about properties
+    int propFlag = 0;
+    if (func->isPropertyReader())
+        propFlag |= 1;
+    if (func->isPropertyWriter())
+        propFlag |= 2;
+    if (propFlag && func->isStatic())
+        propFlag |= 4;
+    QString propStr;
+    if (propFlag != 90)
+        propStr = QString::number(propFlag) + u':';
+
+    if (propFlag != 0)
+        s << "// This method belongs to a property.\n";
+    s << "static const char *funcName = \"";
+    if (propFlag != 0)
+        s << propFlag << ':';
+    s << funcName << "\";\n";
+}
 
 void CppGenerator::writeVirtualMethodNative(TextStream &s,
                                             const AbstractMetaFunctionCPtr &func,
@@ -1394,13 +1172,16 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
                                                     Generator::OriginalTypeDescription)
       << "\n{\n" << indent;
 
-    const QString returnStatement = virtualMethodReturn(s, api(), func,
-                                                        func->modifications());
+    const auto returnStatement = virtualMethodReturn(api(), func,
+                                                     func->modifications());
+
+    if (returnStatement.needsReference)
+        writeVirtualMethodStaticReturnVar(s, func);
 
     const bool isAbstract = func->isAbstract();
     if (isAbstract && func->isModifiedRemoved()) {
-        qCWarning(lcShiboken, "%s", qPrintable(msgPureVirtualFunctionRemoved(func.data())));
-        s << returnStatement << '\n' << outdent << "}\n\n";
+        qCWarning(lcShiboken, "%s", qPrintable(msgPureVirtualFunctionRemoved(func.get())));
+        s << returnStatement.statement << '\n' << outdent << "}\n\n";
         return;
     }
 
@@ -1429,7 +1210,7 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
     s << "if (m_PyMethodCache[" << cacheIndex << "])" << (multi_line ? " {\n" : "\n")
         << indent;
     writeVirtualMethodCppCall(s, func, funcName, snips, lastArg, retType,
-                              returnStatement, false);
+                              returnStatement.statement, false);
     s << outdent;
     if (multi_line)
         s << "}\n";
@@ -1437,34 +1218,33 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
     s << "Shiboken::GilState gil;\n";
 
     // Get out of virtual method call if someone already threw an error.
-    s << "if (PyErr_Occurred())\n" << indent
-        << returnStatement << '\n' << outdent;
-
-    // PYSIDE-1019: Add info about properties
-    int propFlag = 0;
-    if (func->isPropertyReader())
-        propFlag |= 1;
-    if (func->isPropertyWriter())
-        propFlag |= 2;
-    if (propFlag && func->isStatic())
-        propFlag |= 4;
-    QString propStr;
-    if (propFlag)
-        propStr = QString::number(propFlag) + u':';
+    s << "if (" << shibokenErrorsOccurred << ")\n" << indent
+        << returnStatement.statement << '\n' << outdent;
 
     s << "static PyObject *nameCache[2] = {};\n";
-    if (propFlag)
-        s << "// This method belongs to a property.\n";
-    s << "static const char *funcName = \"" << propStr << funcName << "\";\n"
-        << "Shiboken::AutoDecRef " << PYTHON_OVERRIDE_VAR
+    writeFuncNameVar(s, func, funcName);
+    s << "Shiboken::AutoDecRef " << PYTHON_OVERRIDE_VAR
         << "(Shiboken::BindingManager::instance().getOverride(this, nameCache, funcName));\n"
         << "if (" << PYTHON_OVERRIDE_VAR << ".isNull()) {\n" << indent;
     if (useOverrideCaching(func->ownerClass()))
         s << "m_PyMethodCache[" << cacheIndex << "] = true;\n";
     writeVirtualMethodCppCall(s, func, funcName, snips, lastArg, retType,
-                              returnStatement, true);
+                              returnStatement.statement, true);
     s << outdent << "}\n\n"; //WS
 
+    if (!snips.isEmpty()) {
+        writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionPyOverride,
+                       TypeSystem::ShellCode, func, false, lastArg);
+    }
+
+    writeVirtualMethodPythonOverride(s, func, snips, returnStatement);
+}
+
+void CppGenerator::writeVirtualMethodPythonOverride(TextStream &s,
+                                                    const AbstractMetaFunctionCPtr &func,
+                                                    const CodeSnipList &snips,
+                                                    const VirtualMethodReturn &returnStatement) const
+{
     writeConversionRule(s, func, TypeSystem::TargetLangCode, false);
 
     bool invalidateReturn = false;
@@ -1487,7 +1267,7 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
     auto arguments = func->arguments();
     auto removedEnd = std::stable_partition(arguments.begin(), arguments.end(),
                                             isArgumentNotRemoved);
-    if (isAbstract) { // Base function is not called, indicate unused arguments.
+    if (func->isAbstract()) { // Base function is not called, indicate unused arguments.
         for (auto it = removedEnd; it != arguments.end(); ++it)
             s << sbkUnusedVariableCast(it->name());
     }
@@ -1533,7 +1313,7 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
             if (argCount > 0) {
                 s << "PyObject_Vectorcall(" << PYTHON_OVERRIDE_VAR << ", "
                     << PYTHON_ARGS_ARRAY << ", " << argCount << ", nullptr));\n";
-                for (int argIndex : qAsConst(invalidateArgs)) {
+                for (int argIndex : std::as_const(invalidateArgs)) {
                     s << "if (invalidateArg" << argIndex << ")\n" << indent
                         << "Shiboken::Object::invalidate(" << PYTHON_ARGS_ARRAY
                         << '[' << (argIndex - 1) << "]);\n" << outdent;
@@ -1558,12 +1338,13 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
 
         s << "if (" << PYTHON_RETURN_VAR << ".isNull()) {\n" << indent
             << "// An error happened in python code!\n"
-            << "PyErr_Print();\n"
-            << returnStatement << "\n" << outdent
+            << "Shiboken::Errors::storePythonOverrideErrorOrPrint(\""
+            << func->ownerClass()->name() << "\", funcName);\n"
+            << returnStatement.statement << "\n" << outdent
         << "}\n";
 
         if (invalidateReturn) {
-            s << "bool invalidateArg0 = " << PYTHON_RETURN_VAR << "->ob_refcnt == 1;\n"
+            s << "bool invalidateArg0 = Py_REFCNT(" << PYTHON_RETURN_VAR << ") == 1;\n"
                 << "if (invalidateArg0)\n" << indent
                 << "Shiboken::Object::releaseOwnership(" << PYTHON_RETURN_VAR
                 << ".object());\n" << outdent;
@@ -1571,7 +1352,7 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
 
         if (!func->isVoid()) {
 
-            if (func->modifiedTypeName() != cPyObjectT()) {
+            if (func->modifiedTypeName() != cPyObjectT) {
 
                 s << "// Check return type\n";
 
@@ -1583,10 +1364,10 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
                         << PYTHON_RETURN_VAR << ");\n" << outdent
                     << "if (!" << PYTHON_TO_CPP_VAR << ") {\n" << indent
                         << "Shiboken::Warnings::warnInvalidReturnValue(\""
-                        << func->ownerClass()->name() << "\", \"" << funcName << "\", "
+                        << func->ownerClass()->name() << "\", funcName, "
                         << getVirtualFunctionReturnTypeName(func) << ", "
                         << "Py_TYPE(" << PYTHON_RETURN_VAR << ")->tp_name);\n"
-                        << returnStatement << '\n' << outdent
+                        << returnStatement.statement << '\n' << outdent
                     << "}\n";
 
                 } else {
@@ -1605,10 +1386,10 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
                         s << " && " << PYTHON_RETURN_VAR << " != Py_None";
                     s << ") {\n" << indent
                         << "Shiboken::Warnings::warnInvalidReturnValue(\""
-                        << func->ownerClass()->name() << "\", \"" << funcName << "\", "
+                        << func->ownerClass()->name() << "\", funcName, "
                         << getVirtualFunctionReturnTypeName(func) << ", "
                         << "Py_TYPE(" << PYTHON_RETURN_VAR << ")->tp_name);\n"
-                        << returnStatement << '\n' << outdent
+                        << returnStatement.statement << '\n' << outdent
                     << "}\n";
 
                 }
@@ -1645,13 +1426,14 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
 
     if (!func->isVoid()) {
         s << "return ";
+        TypeEntryCPtr retType = func->type().typeEntry();
         if (avoidProtectedHack() && retType->isEnum()) {
             auto metaEnum = api().findAbstractMetaEnum(retType);
             bool isProtectedEnum = metaEnum.has_value() && metaEnum->isProtected();
             if (isProtectedEnum) {
                 QString typeCast;
                 if (metaEnum->enclosingClass())
-                    typeCast += u"::"_s + metaEnum->enclosingClass()->qualifiedCppName();
+                    typeCast += getFullTypeName(metaEnum->enclosingClass());
                 typeCast += u"::"_s + metaEnum->name();
                 s << '(' << typeCast << ')';
             }
@@ -1665,6 +1447,28 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
     s << outdent << "}\n\n";
 }
 
+void CppGenerator::writeUserAddedPythonOverride(TextStream &s,
+                                                const AbstractMetaFunctionCPtr &func) const
+{
+    TypeEntryCPtr retType = func->type().typeEntry();
+    const QString funcName = func->isOperatorOverload()
+        ? pythonOperatorFunctionName(func) : func->definitionNames().constFirst();
+
+    const CodeSnipList snips = func->hasInjectedCode()
+        ? func->injectedCodeSnips() : CodeSnipList();
+
+    QString prefix = wrapperName(func->ownerClass()) + u"::"_s;
+    s << '\n' << functionSignature(func, prefix, QString(), Generator::SkipDefaultValues |
+                                   Generator::OriginalTypeDescription)
+      << "\n{\n" << indent << sbkUnusedVariableCast("gil");
+
+    writeFuncNameVar(s, func, funcName);
+
+    const auto returnStatement = virtualMethodReturn(api(), func,
+                                                     func->modifications());
+    writeVirtualMethodPythonOverride(s, func, snips, returnStatement);
+}
+
 void CppGenerator::writeMetaObjectMethod(TextStream &s,
                                          const GeneratorContext &classContext) const
 {
@@ -1672,7 +1476,7 @@ void CppGenerator::writeMetaObjectMethod(TextStream &s,
     const QString wrapperClassName = classContext.wrapperName();
     const QString qualifiedCppName = classContext.metaClass()->qualifiedCppName();
     s << "const QMetaObject *" << wrapperClassName << "::metaObject() const\n{\n";
-    s << indent << "if (QObject::d_ptr->metaObject)\n"
+    s << indent << "if (QObject::d_ptr->metaObject != nullptr)\n"
         << indent << "return QObject::d_ptr->dynamicMetaObject();\n" << outdent
         << "SbkObject *pySelf = Shiboken::BindingManager::instance().retrieveWrapper(this);\n"
         << "if (pySelf == nullptr)\n"
@@ -1715,68 +1519,15 @@ void CppGenerator::writeMetaCast(TextStream &s,
     const QString wrapperClassName = classContext.wrapperName();
     const QString qualifiedCppName = classContext.metaClass()->qualifiedCppName();
     s << "void *" << wrapperClassName << "::qt_metacast(const char *_clname)\n{\n"
-        << indent << "if (!_clname)\n" << indent << "return {};\n" << outdent
+        << indent << "if (_clname == nullptr)\n" << indent << "return {};\n" << outdent
         << "SbkObject *pySelf = Shiboken::BindingManager::instance().retrieveWrapper(this);\n"
-        << "if (pySelf && PySide::inherits(Py_TYPE(pySelf), _clname))\n"
+        << "if (pySelf != nullptr && PySide::inherits(Py_TYPE(pySelf), _clname))\n"
         << indent << "return static_cast<void *>(const_cast< "
         << wrapperClassName << " *>(this));\n" << outdent
         << "return " << qualifiedCppName << "::qt_metacast(_clname);\n"
         << outdent << "}\n\n";
 }
 
-void CppGenerator::writeFlagsConverterFunctions(TextStream &s,
-                                                const FlagsTypeEntryCPtr &flagsType,
-                                                const QString &enumTypeName,
-                                                const QString &flagsCppTypeName,
-                                                const QString &enumTypeCheck) const
-{
-    Q_ASSERT(flagsType);
-    const QString flagsTypeName = fixedCppTypeName(flagsType);
-    const QString flagsPythonType = cpythonTypeNameExt(flagsType);
-
-    StringStream c(TextStream::Language::Cpp);
-    c << "*reinterpret_cast<" << flagsCppTypeName << " *>(cppOut) =\n"
-        << "    " << flagsCppTypeName
-        << "(QFlag(int(PySide::QFlags::getValue(reinterpret_cast<PySideQFlagsObject *>(pyIn)))))"
-        << ";\n";
-    writePythonToCppFunction(s, c.toString(), flagsTypeName, flagsTypeName);
-
-    QString pyTypeCheck = u"PyObject_TypeCheck(pyIn, "_s + flagsPythonType + u')';
-    writeIsPythonConvertibleToCppFunction(s, flagsTypeName, flagsTypeName, pyTypeCheck);
-
-    c.clear();
-
-    c << "const int castCppIn = int(*reinterpret_cast<const "
-        << flagsCppTypeName << " *>(cppIn));\n" << "return "
-        << "reinterpret_cast<PyObject *>(PySide::QFlags::newObject(castCppIn, "
-        << flagsPythonType << "));\n";
-    writeCppToPythonFunction(s, c.toString(), flagsTypeName, flagsTypeName);
-    s << '\n';
-
-    c.clear();
-    c << "*reinterpret_cast<" << flagsCppTypeName << " *>(cppOut) =\n"
-      << "    " << flagsCppTypeName
-      << "(QFlag(int(Shiboken::Enum::getValue(pyIn))));\n";
-
-    writePythonToCppFunction(s, c.toString(), enumTypeName, flagsTypeName);
-    writeIsPythonConvertibleToCppFunction(s, enumTypeName, flagsTypeName, enumTypeCheck);
-
-    c.clear();
-    c << "Shiboken::AutoDecRef pyLong(PyNumber_Long(pyIn));\n"
-      << "*reinterpret_cast<" << flagsCppTypeName << " *>(cppOut) =\n"
-      << "    " << flagsCppTypeName
-      << "(QFlag(int(PyLong_AsLong(pyLong.object()))));\n";
-    // PYSIDE-898: Include an additional condition to detect if the type of the
-    // enum corresponds to the object that is being evaluated.
-    // Using only `PyNumber_Check(...)` is too permissive,
-    // then we would have been unable to detect the difference between
-    // a PolarOrientation and Qt::AlignmentFlag, which was the main
-    // issue of the bug.
-    const QString numberCondition = u"PyNumber_Check(pyIn) && "_s + enumTypeCheck;
-    writePythonToCppFunction(s, c.toString(), u"number"_s, flagsTypeName);
-    writeIsPythonConvertibleToCppFunction(s, u"number"_s, flagsTypeName, numberCondition);
-}
-
 static void generateDeprecatedValueWarnings(TextStream &c,
                                             const AbstractMetaEnum &metaEnum,
                                             bool useSurrogateName)
@@ -1796,14 +1547,15 @@ static void generateDeprecatedValueWarnings(TextStream &c,
             << "\", \"" << v.name() << "\");\nbreak;\n" << outdent;
     }
     if (deprecatedValues.size() < metaEnum.values().size())
-        c << "default:\n" << indent << "break;\n" << outdent << "}\n";
+        c << "default:\n" << indent << "break;\n" << outdent;
+    c << "}\n";
 }
 
 void CppGenerator::writeEnumConverterFunctions(TextStream &s, const AbstractMetaEnum &metaEnum) const
 {
     if (metaEnum.isPrivate() || metaEnum.isAnonymous())
         return;
-    EnumTypeEntryPtr enumType = metaEnum.typeEntry();
+    EnumTypeEntryCPtr enumType = metaEnum.typeEntry();
     Q_ASSERT(enumType);
     QString typeName = fixedCppTypeName(enumType);
     QString enumPythonType = cpythonTypeNameExt(enumType);
@@ -1824,6 +1576,8 @@ void CppGenerator::writeEnumConverterFunctions(TextStream &s, const AbstractMeta
         generateDeprecatedValueWarnings(c, metaEnum, useSurrogateName);
 
     c << "*reinterpret_cast<" << cppTypeName << " *>(cppOut) = value;\n";
+
+    ConfigurableScope configScope(s, enumType);
     writePythonToCppFunction(s, c.toString(), typeName, typeName);
 
     QString pyTypeCheck = u"PyObject_TypeCheck(pyIn, "_s + enumPythonType + u')';
@@ -1836,16 +1590,36 @@ void CppGenerator::writeEnumConverterFunctions(TextStream &s, const AbstractMeta
         << "Shiboken::Enum::newItem(" << enumPythonType << ", castCppIn);\n";
     writeCppToPythonFunction(s, c.toString(), typeName, typeName);
     s << '\n';
+}
 
-    // QFlags part.
-    if (auto flags = enumType->flags(); !flags.isNull()) {
-        const QString flagsCppTypeName = useSurrogateName
-            ? cppTypeName : getFullTypeName(flags).trimmed();
-        writeFlagsConverterFunctions(s, flags, typeName, flagsCppTypeName, pyTypeCheck);
+static void writePointerToPythonConverter(TextStream &c,
+                                          const AbstractMetaClassCPtr &metaClass,
+                                          const QString &typeName,
+                                          const QString &cpythonType)
+{
+    c << "auto *pyOut = reinterpret_cast<PyObject *>(Shiboken::BindingManager::instance().retrieveWrapper(cppIn));\n"
+        << "if (pyOut) {\n" << indent
+        << "Py_INCREF(pyOut);\nreturn pyOut;\n" << outdent
+        << "}\n";
+
+    const QString nameFunc = metaClass->typeEntry()->polymorphicNameFunction();
+    if (nameFunc.isEmpty() && !metaClass->hasVirtualDestructor()) {
+        c << "return Shiboken::Object::newObjectWithHeuristics("
+            << cpythonType << ", const_cast<void *>(cppIn), false);\n";
+        return;
     }
+
+    c   << "auto *tCppIn = reinterpret_cast<const " << typeName << R"( *>(cppIn);
+const char *typeName = )";
+    if (nameFunc.isEmpty())
+        c << "typeid(*tCppIn).name();\n";
+    else
+        c << nameFunc << "(tCppIn);\n";
+    c << "return Shiboken::Object::newObjectForPointer("
+        << cpythonType << ", const_cast<void *>(cppIn), false, typeName);\n";
 }
 
-void CppGenerator::writeConverterFunctions(TextStream &s, const AbstractMetaClass *metaClass,
+void CppGenerator::writeConverterFunctions(TextStream &s, const AbstractMetaClassCPtr &metaClass,
                                            const GeneratorContext &classContext) const
 {
     s << "// Type conversion functions.\n\n";
@@ -1886,34 +1660,11 @@ void CppGenerator::writeConverterFunctions(TextStream &s, const AbstractMetaClas
     // C++ pointer to a Python wrapper, keeping identity.
     s << "// C++ to Python pointer conversion - tries to find the Python wrapper for the C++ object (keeps object identity).\n";
     c.clear();
-    if (usePySideExtensions() && metaClass->isQObject()) {
+    if (usePySideExtensions() && isQObject(metaClass)) {
         c << "return PySide::getWrapperForQObject(reinterpret_cast<"
             << typeName << " *>(const_cast<void *>(cppIn)), " << cpythonType << ");\n";
     } else {
-        c << "auto pyOut = reinterpret_cast<PyObject *>(Shiboken::BindingManager::instance().retrieveWrapper(cppIn));\n"
-            << "if (pyOut) {\n" << indent
-            << "Py_INCREF(pyOut);\nreturn pyOut;\n" << outdent
-            << "}\n"
-            << "bool changedTypeName = false;\n"
-            << "auto tCppIn = reinterpret_cast<const " << typeName << R"( *>(cppIn);
-const char *typeName = )";
-
-        const QString nameFunc = metaClass->typeEntry()->polymorphicNameFunction();
-        if (nameFunc.isEmpty())
-            c << "typeid(*tCppIn).name();\n";
-        else
-            c << nameFunc << "(tCppIn);\n";
-        c << R"(auto sbkType = Shiboken::ObjectType::typeForTypeName(typeName);
-if (sbkType && Shiboken::ObjectType::hasSpecialCastFunction(sbkType)) {
-    typeName = typeNameOf(tCppIn);
-    changedTypeName = true;
-}
-)"
-            << "PyObject *result = Shiboken::Object::newObject(" << cpythonType
-            << R"(, const_cast<void *>(cppIn), false, /* exactType */ changedTypeName, typeName);
-if (changedTypeName)
-    delete [] typeName;
-return result;)";
+        writePointerToPythonConverter(c, metaClass, typeName, cpythonType);
     }
     std::swap(targetTypeName, sourceTypeName);
     writeCppToPythonFunction(s, c.toString(), sourceTypeName, targetTypeName);
@@ -1942,7 +1693,7 @@ return result;)";
         c << "auto *source = reinterpret_cast<const " << typeName << " *>(cppIn);\n";
     }
     c << "return Shiboken::Object::newObject(" << cpythonType
-        << ", new ::" << classContext.effectiveClassName() << '('
+        << ", new " << globalScopePrefix(classContext) << classContext.effectiveClassName() << '('
         << (isUniquePointer ? "std::move(*source)" : "*source")
         << "), true, true);";
     writeCppToPythonFunction(s, c.toString(), sourceTypeName, targetTypeName);
@@ -1952,7 +1703,7 @@ return result;)";
     s << "// Python to C++ copy conversion.\n";
     sourceTypeName = metaClass->name();
 
-    targetTypeName = sourceTypeName + QStringLiteral("_COPY");
+    targetTypeName = sourceTypeName + "_COPY"_L1;
     c.clear();
 
     QString pyInVariable = u"pyIn"_s;
@@ -1961,7 +1712,7 @@ return result;)";
         c << '*' << outPtr << " = *"
             << cpythonWrapperCPtr(typeEntry, pyInVariable) << ';';
     } else {
-        auto ste = qSharedPointerCast<const SmartPointerTypeEntry>(typeEntry);
+        auto ste = std::static_pointer_cast<const SmartPointerTypeEntry>(typeEntry);
         const QString resetMethod = ste->resetMethod();
         c << "auto *ptr = " << outPtr << ";\n";
         c << "if (" << pyInVariable << " == Py_None)\n" << indent;
@@ -1999,7 +1750,7 @@ return result;)";
         QString toCppConv;
         QString toCppPreConv;
         if (conv->isConversionOperator()) {
-            const AbstractMetaClass *sourceClass = conv->ownerClass();
+            const auto sourceClass = conv->ownerClass();
             typeCheck = u"PyObject_TypeCheck(pyIn, "_s
                         + cpythonTypeNameExt(sourceClass->typeEntry()) + u')';
             toCppConv = u'*' + cpythonWrapperCPtr(sourceClass->typeEntry(),
@@ -2033,14 +1784,14 @@ return result;)";
                 StringStream pc(TextStream::Language::Cpp);
                 pc << getFullTypeNameWithoutModifiers(sourceType) << " cppIn"
                     << minimalConstructorExpression(api(), sourceType) << ";\n";
-                writeToCppConversion(pc, sourceType, nullptr, pyInVariable,
+                writeToCppConversion(pc, sourceType, pyInVariable,
                                      u"cppIn"_s);
                 pc << ';';
                 toCppPreConv = pc.toString();
                 toCppConv.append(u"cppIn"_s);
             } else if (!sourceType.isWrapperType()) {
                 StringStream tcc(TextStream::Language::Cpp);
-                writeToCppConversion(tcc, sourceType, metaClass, pyInVariable,
+                writeToCppConversion(tcc, sourceType, pyInVariable,
                                      u"/*BOZO-1061*/"_s);
                 toCppConv = tcc.toString();
             }
@@ -2052,7 +1803,7 @@ return result;)";
     }
 
     if (typeEntry->isValue()) {
-        auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry);
+        auto vte = std::static_pointer_cast<const ValueTypeEntry>(typeEntry);
         writeCustomConverterFunctions(s, vte->customConversion());
     }
 }
@@ -2060,7 +1811,7 @@ return result;)";
 void CppGenerator::writeCustomConverterFunctions(TextStream &s,
                                                  const CustomConversionPtr &customConversion) const
 {
-    if (customConversion.isNull())
+    if (!customConversion)
         return;
     const TargetToNativeConversions &toCppConversions = customConversion->targetToNativeConversions();
     if (toCppConversions.isEmpty())
@@ -2072,7 +1823,7 @@ void CppGenerator::writeCustomConverterFunctions(TextStream &s,
     s << '\n';
 }
 
-void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass *metaClass,
+void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClassCPtr &metaClass,
                                           const GeneratorContext &classContext) const
 {
     const auto typeEntry = metaClass->typeEntry();
@@ -2096,9 +1847,8 @@ void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass
 
     auto writeConversions = [&s](const QString &signature)
     {
-        s << "Shiboken::Conversions::registerConverterName(converter, \"" << signature << "\");\n"
-            << "Shiboken::Conversions::registerConverterName(converter, \"" << signature << "*\");\n"
-            << "Shiboken::Conversions::registerConverterName(converter, \"" << signature << "&\");\n";
+        s << registerConverterName(signature) << registerConverterName(signature + u'*')
+            << registerConverterName(signature + u'&');
     };
 
     auto writeConversionsForType = [writeConversions](const QString &fullTypeName)
@@ -2123,14 +1873,14 @@ void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass
                                                Qt::SkipEmptyParts);
         while (!lst.isEmpty()) {
             QString signature = lst.join(u"::"_s);
-            writeConversions(smartPointerName + u'<' + signature + u" >"_s);
+            writeConversions(smartPointerName + u'<' + signature + u'>');
             lst.removeFirst();
         }
 
         writeConversionsForType(smartPointerType);
     }
 
-    s << "Shiboken::Conversions::registerConverterName(converter, typeid(::";
+    s << "Shiboken::Conversions::registerConverterName(converter, typeid(" << m_gsp;
     QString qualifiedCppNameInvocation;
     if (!classContext.forSmartPointer())
         qualifiedCppNameInvocation = metaClass->qualifiedCppName();
@@ -2140,17 +1890,15 @@ void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass
     s << qualifiedCppNameInvocation << ").name());\n";
 
     if (classContext.useWrapper()) {
-        s << "Shiboken::Conversions::registerConverterName(converter, typeid(::"
+        s << "Shiboken::Conversions::registerConverterName(converter, typeid("
             << classContext.wrapperName() << ").name());\n";
     }
 
-    s << '\n';
-
     if (!typeEntry->isValue() && !typeEntry->isSmartPointer())
         return;
 
     // Python to C++ copy (value, not pointer neither reference) conversion.
-    s << "// Add Python to C++ copy (value, not pointer neither reference) conversion to type converter.\n";
+    s << "\n// Add Python to C++ copy (value, not pointer neither reference) conversion to type converter.\n";
     sourceTypeName = metaClass->name();
     targetTypeName = sourceTypeName + u"_COPY"_s;
     QString toCpp = pythonToCppFunctionName(sourceTypeName, targetTypeName);
@@ -2185,7 +1933,7 @@ void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass
     }
 
     if (typeEntry->isValue()) {
-        auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry);
+        auto vte = std::static_pointer_cast<const ValueTypeEntry>(typeEntry);
         writeCustomConverterRegister(s, vte->customConversion(), u"converter"_s);
     }
 }
@@ -2194,7 +1942,7 @@ void CppGenerator::writeCustomConverterRegister(TextStream &s,
                                                 const CustomConversionPtr &customConversion,
                                                 const QString &converterVar)
 {
-    if (customConversion.isNull())
+    if (!customConversion)
         return;
     const TargetToNativeConversions &toCppConversions =
         customConversion->targetToNativeConversions();
@@ -2215,46 +1963,7 @@ void CppGenerator::writeContainerConverterFunctions(TextStream &s,
     writePythonToCppConversionFunctions(s, containerType);
 }
 
-// Helpers to collect all smart pointer pointee base classes
-static AbstractMetaClassCList findSmartPointeeBaseClasses(const ApiExtractorResult &api,
-                                                          const AbstractMetaType &smartPointerType)
-{
-    AbstractMetaClassCList result;
-    auto instantiationsTe = smartPointerType.instantiations().at(0).typeEntry();
-    auto targetClass = AbstractMetaClass::findClass(api.classes(), instantiationsTe);
-    if (targetClass != nullptr)
-        result = targetClass->allTypeSystemAncestors();
-    return result;
-}
-
-void CppGenerator::writeSmartPointerConverterFunctions(TextStream &s,
-                                                       const AbstractMetaType &smartPointerType) const
-{
-    const auto baseClasses = findSmartPointeeBaseClasses(api(), smartPointerType);
-    if (baseClasses.isEmpty())
-        return;
-
-    auto smartPointerTypeEntry =
-        qSharedPointerCast<const SmartPointerTypeEntry>(smartPointerType.typeEntry());
-
-    // TODO: Missing conversion to smart pointer pointer type:
-
-    s << "// Register smartpointer conversion for all derived classes\n";
-    for (auto *base : baseClasses) {
-        auto baseTe = base->typeEntry();
-        if (smartPointerTypeEntry->matchesInstantiation(baseTe)) {
-            if (auto opt = findSmartPointerInstantiation(smartPointerTypeEntry, baseTe)) {
-                const auto smartTargetType = opt.value();
-                s << "// SmartPointer derived class: "
-                    << smartTargetType.cppSignature() << "\n";
-                writePythonToCppConversionFunctions(s, smartPointerType,
-                                                    smartTargetType, {}, {}, {});
-            }
-        }
-    }
-}
-
-bool CppGenerator::needsArgumentErrorHandling(const OverloadData &overloadData) const
+bool CppGenerator::needsArgumentErrorHandling(const OverloadData &overloadData)
 {
     if (overloadData.maxArgs() > 0)
         return true;
@@ -2263,15 +1972,16 @@ bool CppGenerator::needsArgumentErrorHandling(const OverloadData &overloadData)
         return false;
     auto rfunc = overloadData.referenceFunction();
     return rfunc->functionType() == AbstractMetaFunction::ConstructorFunction
-        && rfunc->ownerClass()->isQObject();
+        && isQObject(rfunc->ownerClass());
 }
 
-void CppGenerator::writeMethodWrapperPreamble(TextStream &s,const OverloadData &overloadData,
+void CppGenerator::writeMethodWrapperPreamble(TextStream &s,
+                                              const OverloadData &overloadData,
                                               const GeneratorContext &context,
-                                              ErrorReturn errorReturn) const
+                                              ErrorReturn errorReturn)
 {
     const auto rfunc = overloadData.referenceFunction();
-    const AbstractMetaClass *ownerClass = rfunc->targetLangOwner();
+    const auto ownerClass = rfunc->targetLangOwner();
     Q_ASSERT(ownerClass == context.metaClass());
     int minArgs = overloadData.minArgs();
     int maxArgs = overloadData.maxArgs();
@@ -2281,7 +1991,9 @@ void CppGenerator::writeMethodWrapperPreamble(TextStream &s,const OverloadData &
     if (rfunc->isConstructor()) {
         // Check if the right constructor was called.
         if (!ownerClass->hasPrivateDestructor()) {
-            s << "if (Shiboken::Object::isUserType(self) && !Shiboken::ObjectType::canCallConstructor(self->ob_type, Shiboken::SbkType< ::";
+            s << "if (Shiboken::Object::isUserType(self) && "
+              << "!Shiboken::ObjectType::canCallConstructor(self->ob_type, Shiboken::SbkType< "
+              << m_gsp;
             QString qualifiedCppName;
             if (!context.forSmartPointer())
                 qualifiedCppName = ownerClass->qualifiedCppName();
@@ -2291,7 +2003,7 @@ void CppGenerator::writeMethodWrapperPreamble(TextStream &s,const OverloadData &
             s << qualifiedCppName << " >()))\n" << indent << errorReturn << outdent << '\n';
         }
         // Declare pointer for the underlying C++ object.
-        s << "::" << context.effectiveClassName() << " *cptr{};\n";
+        s << globalScopePrefix(context) << context.effectiveClassName() << " *cptr{};\n";
 
         initPythonArguments = maxArgs > 0;
 
@@ -2311,11 +2023,18 @@ void CppGenerator::writeMethodWrapperPreamble(TextStream &s,const OverloadData &
         initPythonArguments = minArgs != maxArgs || maxArgs > 1;
     }
 
-    if (needsArgumentErrorHandling(overloadData)) {
-        s << R"(Shiboken::AutoDecRef errInfo{};
-static const char fullName[] = ")" << fullPythonFunctionName(rfunc, true)
-            << "\";\nSBK_UNUSED(fullName)\n";
-    }
+    if (needsArgumentErrorHandling(overloadData))
+        s << "Shiboken::AutoDecRef errInfo{};\n";
+
+    s << "static const char fullName[] = \"" << fullPythonFunctionName(rfunc, true)
+        << "\";\nSBK_UNUSED(fullName)\n"
+        << "Shiboken::PythonContextMarker pcm;\n";
+    // PYSIDE-2335: Mark blocking calls like `exec` or `run` as such.
+    bool isBlockingFunction = rfunc->name() == u"exec"_s || rfunc->name() == u"exec_"_s
+                              || rfunc->name() == u"run"_s;
+    if (isBlockingFunction)
+        s << "pcm.setBlocking();\n";
+
     if (maxArgs > 0) {
         s << "int overloadId = -1;\n"
             << PYTHON_TO_CPPCONVERSION_STRUCT << ' ' << PYTHON_TO_CPP_VAR;
@@ -2341,20 +2060,20 @@ void CppGenerator::writeConstructorWrapper(TextStream &s, const OverloadData &ov
     const ErrorReturn errorReturn = ErrorReturn::MinusOne;
 
     const auto rfunc = overloadData.referenceFunction();
-    const AbstractMetaClass *metaClass = rfunc->ownerClass();
+    const auto metaClass = rfunc->ownerClass();
 
     s << "static int\n";
     s << cpythonFunctionName(rfunc)
         << "(PyObject *self, PyObject *args, PyObject *kwds)\n{\n" << indent;
     if (overloadData.maxArgs() == 0 || metaClass->isAbstract())
-        s << sbkUnusedVariableCast(u"args"_s);
-    s << sbkUnusedVariableCast(u"kwds"_s);
+        s << sbkUnusedVariableCast("args");
+    s << sbkUnusedVariableCast("kwds");
 
-    const bool needsMetaObject = usePySideExtensions() && metaClass->isQObject();
+    const bool needsMetaObject = usePySideExtensions() && isQObject(metaClass);
     if (needsMetaObject)
         s << "const QMetaObject *metaObject;\n";
 
-    s << "SbkObject *sbkSelf = reinterpret_cast<SbkObject *>(self);\n";
+    s << "auto *sbkSelf = reinterpret_cast<SbkObject *>(self);\n";
 
     if (metaClass->isAbstract() || metaClass->baseClassNames().size() > 1) {
         s << "PyTypeObject *type = self->ob_type;\n"
@@ -2365,11 +2084,11 @@ void CppGenerator::writeConstructorWrapper(TextStream &s, const OverloadData &ov
     if (metaClass->isAbstract()) {
         // C++ Wrapper disabled: Abstract C++ class cannot be instantiated.
         if (metaClass->typeEntry()->typeFlags().testFlag(ComplexTypeEntry::DisableWrapper)) {
-            s << sbkUnusedVariableCast(u"sbkSelf"_s)
-                << sbkUnusedVariableCast(u"type"_s)
-                << sbkUnusedVariableCast(u"myType"_s);
+            s << sbkUnusedVariableCast("sbkSelf")
+                << sbkUnusedVariableCast("type")
+                << sbkUnusedVariableCast("myType");
             if (needsMetaObject)
-                s << sbkUnusedVariableCast(u"metaObject"_s);
+                s << sbkUnusedVariableCast("metaObject");
             s << "Shiboken::Errors::setInstantiateAbstractClassDisabledWrapper(\""
                 << metaClass->qualifiedCppName() << "\");\n" << errorReturn << outdent
                 << "}\n\n";
@@ -2401,19 +2120,29 @@ void CppGenerator::writeConstructorWrapper(TextStream &s, const OverloadData &ov
     s << '\n';
 
     if (overloadData.maxArgs() > 0)
-        writeOverloadedFunctionDecisor(s, overloadData);
+        writeOverloadedFunctionDecisor(s, overloadData, errorReturn);
+
+    // Handles Python Multiple Inheritance
+    QString pre = needsMetaObject ? u"bool usesPyMI = "_s : u""_s;
+    s << "\n// PyMI support\n"
+        << pre << "Shiboken::callInheritedInit(self, args, kwds, fullName);\n"
+        << "if (" << shibokenErrorsOccurred << ")\n"
+        << indent << errorReturn << outdent << "\n";
 
     writeFunctionCalls(s, overloadData, classContext, errorReturn);
     s << '\n';
 
     const QString typeName = classContext.forSmartPointer()
         ? classContext.preciseType().cppSignature() : metaClass->qualifiedCppName();
-    s << "if (PyErr_Occurred() || !Shiboken::Object::setCppPointer(sbkSelf, Shiboken::SbkType< ::"
-        << typeName << " >(), cptr)) {\n"
+    s << "if (" << shibokenErrorsOccurred
+        << " || !Shiboken::Object::setCppPointer(sbkSelf, Shiboken::SbkType< "
+        << globalScopePrefix(classContext) << typeName << " >(), cptr)) {\n"
         <<  indent << "delete cptr;\n" << errorReturn << outdent
         << "}\n";
     if (overloadData.maxArgs() > 0)
-        s << "if (!cptr) goto " << cpythonFunctionName(rfunc) << "_TypeError;\n\n";
+        s << "if (cptr == nullptr)\n" << indent
+            << "return " << returnErrorWrongArguments(overloadData, errorReturn) << ";\n\n"
+            << outdent;
 
     s << "Shiboken::Object::setValidCpp(sbkSelf, true);\n";
     // If the created C++ object has a C++ wrapper the ownership is assigned to Python
@@ -2435,8 +2164,9 @@ void CppGenerator::writeConstructorWrapper(TextStream &s, const OverloadData &ov
             << "PySide::Signal::updateSourceObject(self);\n"
             << "metaObject = cptr->metaObject(); // <- init python qt properties\n"
             << "if (!errInfo.isNull() && PyDict_Check(errInfo.object())) {\n" << indent
-                << "if (!PySide::fillQtProperties(self, metaObject, errInfo))\n" << indent
-                    << "goto " << cpythonFunctionName(rfunc) << "_TypeError;\n" << outdent << outdent
+                << "if (!PySide::fillQtProperties(self, metaObject, errInfo, usesPyMI))\n" << indent
+                    << "return " << returnErrorWrongArguments(overloadData, errorReturn) << ";\n"
+                    << outdent << outdent
             << "};\n";
     }
 
@@ -2474,8 +2204,6 @@ void CppGenerator::writeConstructorWrapper(TextStream &s, const OverloadData &ov
     }
 
     s << "\n\nreturn 1;\n";
-    if (needsArgumentErrorHandling(overloadData))
-        writeErrorSection(s, overloadData, errorReturn);
     s<< outdent << "}\n\n";
 }
 
@@ -2498,9 +2226,9 @@ void CppGenerator::writeMethodWrapper(TextStream &s, const OverloadData &overloa
     }
     s << ")\n{\n" << indent;
     if (rfunc->ownerClass() == nullptr || overloadData.hasStaticFunction())
-        s << sbkUnusedVariableCast(u"self"_s);
+        s << sbkUnusedVariableCast(PYTHON_SELF_VAR);
     if (hasKwdArgs)
-        s << sbkUnusedVariableCast(u"kwds"_s);
+        s << sbkUnusedVariableCast("kwds");
 
     writeMethodWrapperPreamble(s, overloadData, classContext);
 
@@ -2527,7 +2255,8 @@ void CppGenerator::writeMethodWrapper(TextStream &s, const OverloadData &overloa
             << "PyObject *revOpMethod = PyObject_GetAttr(" << PYTHON_ARG << ", attrName);\n"
             << "if (revOpMethod && PyCallable_Check(revOpMethod)) {\n" << indent
             << PYTHON_RETURN_VAR << " = PyObject_CallFunction(revOpMethod, \"O\", self);\n"
-            << "if (PyErr_Occurred() && (PyErr_ExceptionMatches(PyExc_NotImplementedError)"
+            << "if (" << shibokenErrorsOccurred
+            << " && (PyErr_ExceptionMatches(PyExc_NotImplementedError)"
             << " || PyErr_ExceptionMatches(PyExc_AttributeError))) {\n" << indent
             << "PyErr_Clear();\n"
             << "Py_XDECREF(" << PYTHON_RETURN_VAR << ");\n"
@@ -2537,14 +2266,14 @@ void CppGenerator::writeMethodWrapper(TextStream &s, const OverloadData &overloa
             << "Py_XDECREF(revOpMethod);\n\n"
             << outdent << "}\n\n"
             << "// Do not enter here if other object has implemented a reverse operator.\n"
-            << "if (!" << PYTHON_RETURN_VAR << ") {\n" << indent;
+            << "if (" << PYTHON_RETURN_VAR << " == nullptr) {\n" << indent;
         if (maxArgs > 0)
-            writeOverloadedFunctionDecisor(s, overloadData);
+            writeOverloadedFunctionDecisor(s, overloadData, ErrorReturn::Default);
         writeFunctionCalls(s, overloadData, classContext, ErrorReturn::Default);
         s  << outdent << '\n' << "} // End of \"if (!" << PYTHON_RETURN_VAR << ")\"\n";
     } else { // binary shift operator
         if (maxArgs > 0)
-            writeOverloadedFunctionDecisor(s, overloadData);
+            writeOverloadedFunctionDecisor(s, overloadData, ErrorReturn::Default);
         writeFunctionCalls(s, overloadData, classContext, ErrorReturn::Default);
     }
 
@@ -2563,9 +2292,6 @@ void CppGenerator::writeMethodWrapper(TextStream &s, const OverloadData &overloa
         s << "Py_RETURN_NONE;\n";
     }
 
-    if (needsArgumentErrorHandling(overloadData))
-        writeErrorSection(s, overloadData, ErrorReturn::Default);
-
     s<< outdent << "}\n\n";
 }
 
@@ -2573,7 +2299,7 @@ void CppGenerator::writeArgumentsInitializer(TextStream &s, const OverloadData &
                                              ErrorReturn errorReturn)
 {
     const auto rfunc = overloadData.referenceFunction();
-    s << "PyTuple_GET_SIZE(args);\n" << sbkUnusedVariableCast(u"numArgs"_s);
+    s << "PyTuple_GET_SIZE(args);\n" << sbkUnusedVariableCast("numArgs");
 
     int minArgs = overloadData.minArgs();
     int maxArgs = overloadData.maxArgs();
@@ -2602,15 +2328,16 @@ void CppGenerator::writeArgumentsInitializer(TextStream &s, const OverloadData &
 
     // Disable argument count checks for QObject constructors to allow for
     // passing properties as KW args.
-    auto *owner = rfunc->ownerClass();
-    bool isQObjectConstructor = owner != nullptr && owner->isQObject()
+    const auto owner = rfunc->ownerClass();
+    bool isQObjectConstructor = owner && isQObject(owner)
         && rfunc->functionType() == AbstractMetaFunction::ConstructorFunction;
 
     if (usesNamedArguments && !isQObjectConstructor) {
         s << "errInfo.reset(Shiboken::checkInvalidArgumentCount(numArgs, "
             <<  minArgs << ", " << maxArgs << "));\n"
             << "if (!errInfo.isNull())\n" << indent
-            << "goto " << cpythonFunctionName(rfunc) << "_TypeError;\n" << outdent;
+            << "return " << returnErrorWrongArguments(overloadData, errorReturn) << ";\n"
+            << outdent;
     }
 
     const QList<int> invalidArgsLength = overloadData.invalidArgumentLengths();
@@ -2622,7 +2349,8 @@ void CppGenerator::writeArgumentsInitializer(TextStream &s, const OverloadData &
             s << "numArgs == " << invalidArgsLength.at(i);
         }
         s << ")\n" << indent
-            << "goto " << cpythonFunctionName(rfunc) << "_TypeError;\n" << outdent;
+            << "return " << returnErrorWrongArguments(overloadData, errorReturn) << ";\n"
+            << outdent;
     }
     s  << '\n';
 
@@ -2633,7 +2361,7 @@ void CppGenerator::writeArgumentsInitializer(TextStream &s, const OverloadData &
         funcName = rfunc->name();
 
     QString argsVar = overloadData.hasVarargs() ?  u"nonvarargs"_s : u"args"_s;
-    s << "if (!";
+    s << "if (";
     if (usesNamedArguments) {
         s << "PyArg_ParseTuple(" << argsVar << ", \"|" << QByteArray(maxArgs, 'O')
             << ':' << funcName << '"';
@@ -2643,7 +2371,7 @@ void CppGenerator::writeArgumentsInitializer(TextStream &s, const OverloadData &
     }
     for (int i = 0; i < maxArgs; i++)
         s << ", &(" << PYTHON_ARGS << '[' << i << "])";
-    s << "))\n" << indent << errorReturn << outdent << '\n';
+    s << ") == 0)\n" << indent << errorReturn << outdent << '\n';
 }
 
 void CppGenerator::writeCppSelfConversion(TextStream &s, const GeneratorContext &context,
@@ -2654,23 +2382,15 @@ void CppGenerator::writeCppSelfConversion(TextStream &s, const GeneratorContext
         return;
     }
 
-    static const QString pythonSelfVar = u"self"_s;
     if (useWrapperClass)
         s << "static_cast<" << className << " *>(";
-    s << cpythonWrapperCPtr(context.metaClass(), pythonSelfVar);
+    s << cpythonWrapperCPtr(context.metaClass(), PYTHON_SELF_VAR);
     if (useWrapperClass)
         s << ')';
 }
 
-void CppGenerator::writeSmartPointerCppSelfConversion(TextStream &s,
-                                                      const GeneratorContext &context)
-{
-    Q_ASSERT(context.forSmartPointer());
-    s << cpythonWrapperCPtr(context.preciseType(), u"self"_s);
-}
-
-static inline void writeCppSelfVarDef(TextStream &s,
-                                      CppGenerator::CppSelfDefinitionFlags flags = {})
+void CppGenerator::writeCppSelfVarDef(TextStream &s,
+                                      CppSelfDefinitionFlags flags)
 {
     if (flags.testFlag(CppGenerator::CppSelfAsReference))
         s << "auto &" <<  CPP_SELF_VAR << " = *";
@@ -2678,22 +2398,10 @@ static inline void writeCppSelfVarDef(TextStream &s,
         s << "auto *" << CPP_SELF_VAR << " = ";
 }
 
-void CppGenerator::writeSmartPointerCppSelfDefinition(TextStream &s,
-                                                      const GeneratorContext &context,
-                                                      ErrorReturn errorReturn,
-                                                      CppSelfDefinitionFlags flags)
-{
-    Q_ASSERT(context.forSmartPointer());
-    writeInvalidPyObjectCheck(s, u"self"_s, errorReturn);
-    writeCppSelfVarDef(s, flags);
-    writeSmartPointerCppSelfConversion(s, context);
-    s << ";\n";
-}
-
 void CppGenerator::writeCppSelfDefinition(TextStream &s,
                                           const GeneratorContext &context,
                                           ErrorReturn errorReturn,
-                                          CppSelfDefinitionFlags flags) const
+                                          CppSelfDefinitionFlags flags)
 {
     Q_ASSERT(!(flags.testFlag(CppSelfAsReference) && flags.testFlag(HasStaticOverload)));
     if (context.forSmartPointer()) {
@@ -2701,7 +2409,7 @@ void CppGenerator::writeCppSelfDefinition(TextStream &s,
         return;
     }
 
-    const AbstractMetaClass *metaClass = context.metaClass();
+    AbstractMetaClassCPtr metaClass = context.metaClass();
     const auto cppWrapper = context.metaClass()->cppWrapper();
     // In the Python method, use the wrapper to access the protected
     // functions.
@@ -2709,10 +2417,9 @@ void CppGenerator::writeCppSelfDefinition(TextStream &s,
         && cppWrapper.testFlag(AbstractMetaClass::CppProtectedHackWrapper);
     Q_ASSERT(!useWrapperClass || context.useWrapper());
     const QString className = useWrapperClass
-        ? context.wrapperName()
-        : (u"::"_s + metaClass->qualifiedCppName());
+        ? context.wrapperName() : getFullTypeName(metaClass);
 
-    writeInvalidPyObjectCheck(s, u"self"_s, errorReturn);
+    writeInvalidPyObjectCheck(s, PYTHON_SELF_VAR, errorReturn);
 
     if (flags.testFlag(CppSelfAsReference)) {
          writeCppSelfVarDef(s, flags);
@@ -2745,7 +2452,7 @@ void CppGenerator::writeCppSelfDefinition(TextStream &s,
                                           const AbstractMetaFunctionCPtr &func,
                                           const GeneratorContext &context,
                                           ErrorReturn errorReturn,
-                                          CppSelfDefinitionFlags flags) const
+                                          CppSelfDefinitionFlags flags)
 {
     if (!func->ownerClass() || func->isConstructor())
         return;
@@ -2761,24 +2468,32 @@ void CppGenerator::writeCppSelfDefinition(TextStream &s,
     writeCppSelfDefinition(s, context, errorReturn, flags);
 }
 
-void CppGenerator::writeErrorSection(TextStream &s, const OverloadData &overloadData,
-                                     ErrorReturn errorReturn)
+QString CppGenerator::returnErrorWrongArguments(const OverloadData &overloadData,
+                                                       ErrorReturn errorReturn)
 {
     const auto rfunc = overloadData.referenceFunction();
     QString argsVar = overloadData.pythonFunctionWrapperUsesListOfArguments()
         ? u"args"_s : PYTHON_ARG;
-    s << '\n' << cpythonFunctionName(rfunc) << "_TypeError:\n" << indent
-        << "Shiboken::setErrorAboutWrongArguments(" << argsVar << ", fullName, errInfo);\n"
-        << errorReturn << outdent;
+    switch (errorReturn) {
+    case ErrorReturn::Default:
+        return u"Shiboken::returnWrongArguments("_s + argsVar + u", fullName, errInfo)"_s;
+    case ErrorReturn::Zero:
+        return u"Shiboken::returnWrongArguments_Zero("_s + argsVar + u", fullName, errInfo)"_s;
+    case ErrorReturn::MinusOne:
+        return u"Shiboken::returnWrongArguments_MinusOne("_s + argsVar + u", fullName, errInfo)"_s;
+    case ErrorReturn::Void:
+        Q_ASSERT(false);
+    }
+    return {};
 }
 
 void CppGenerator::writeFunctionReturnErrorCheckSection(TextStream &s,
                                                         ErrorReturn errorReturn,
                                                         bool hasReturnValue)
 {
-    s << "if (PyErr_Occurred()";
+    s << "if (" << shibokenErrorsOccurred;
     if (hasReturnValue)
-        s << " || !" << PYTHON_RETURN_VAR;
+        s << " || " << PYTHON_RETURN_VAR << " == nullptr";
     s << ") {\n" << indent;
     if (hasReturnValue)
         s << "Py_XDECREF(" << PYTHON_RETURN_VAR << ");\n";
@@ -2886,7 +2601,7 @@ static void checkTypeViability(const AbstractMetaFunctionCPtr &func)
 }
 
 void CppGenerator::writeTypeCheck(TextStream &s,
-                                  const QSharedPointer<OverloadDataNode> &overloadData,
+                                  const std::shared_ptr<OverloadDataNode> &overloadData,
                                   const QString &argumentName)
 {
     QSet<TypeEntryCPtr> numericTypes;
@@ -2918,7 +2633,7 @@ qsizetype CppGenerator::writeArgumentConversion(TextStream &s,
                                                 const QString &argName,
                                                 const QString &pyArgName,
                                                 ErrorReturn errorReturn,
-                                                const AbstractMetaClass *context,
+                                                const AbstractMetaClassCPtr &context,
                                                 const QString &defaultValue,
                                                 bool castArgumentAsUnused) const
 {
@@ -2950,12 +2665,12 @@ static inline QString arrayHandleType(const AbstractMetaTypeList &nestedArrayTyp
 {
     switch (nestedArrayTypes.size()) {
     case 1:
-        return QStringLiteral("Shiboken::Conversions::ArrayHandle<")
+        return "Shiboken::Conversions::ArrayHandle<"_L1
             + nestedArrayTypes.constLast().minimalSignature() + u'>';
     case 2:
-        return QStringLiteral("Shiboken::Conversions::Array2Handle<")
+        return "Shiboken::Conversions::Array2Handle<"_L1
             + nestedArrayTypes.constLast().minimalSignature()
-            + QStringLiteral(", ")
+            + ", "_L1
             + QString::number(nestedArrayTypes.constFirst().arrayElementCount())
             + u'>';
     }
@@ -2994,7 +2709,7 @@ qsizetype CppGenerator::writePythonToCppTypeConversion(TextStream &s,
                                                   const AbstractMetaType &type,
                                                   const QString &pyIn,
                                                   const QString &cppOut,
-                                                  const AbstractMetaClass *context,
+                                                  const AbstractMetaClassCPtr &context,
                                                   const QString &defaultValue) const
 {
     TypeEntryCPtr typeEntry = type.typeEntry();
@@ -3030,7 +2745,7 @@ qsizetype CppGenerator::writePythonToCppTypeConversion(TextStream &s,
         // conversion for &cppOut
         s << ' ' << cppOutAux;
         // No default value for containers which can also be passed by pointer.
-        if (arg.type != GeneratorArgument::Type::Container)
+        if (arg.type != GeneratorArgument::Type::Container || type.indirections() == 0)
             writeMinimalConstructorExpression(s, api(), type, isPrimitive, defaultValue);
         s << ";\n" << typeName << " *" << cppOut << " = &" << cppOutAux;
     }
@@ -3062,7 +2777,7 @@ qsizetype CppGenerator::writePythonToCppTypeConversion(TextStream &s,
                    || arg.type == GeneratorArgument::Type::Enum
                    || arg.type == GeneratorArgument::Type::Flags) {
             writeMinimalConstructorExpression(s, api(), typeEntry, isPrimitive, defaultValue);
-        } else if (!type.isContainer() && !type.isSmartPointer()) {
+        } else if ((!type.isContainer() || type.indirections() == 0) && !type.isSmartPointer()) {
             writeMinimalConstructorExpression(s, api(), type, isPrimitive, defaultValue);
         }
         break;
@@ -3157,7 +2872,9 @@ void CppGenerator::writeNoneReturn(TextStream &s, const AbstractMetaFunctionCPtr
     }
 }
 
-void CppGenerator::writeOverloadedFunctionDecisor(TextStream &s, const OverloadData &overloadData) const
+void CppGenerator::writeOverloadedFunctionDecisor(TextStream &s,
+                                                  const OverloadData &overloadData,
+                                                  ErrorReturn errorReturn) const
 {
     s << "// Overloaded function decisor\n";
     const auto rfunc = overloadData.referenceFunction();
@@ -3167,7 +2884,7 @@ void CppGenerator::writeOverloadedFunctionDecisor(TextStream &s, const OverloadD
         s << "// " << i << ": ";
         if (func->isStatic())
             s << "static ";
-        if (const auto *decl = func->declaringClass())
+        if (const auto &decl = func->declaringClass())
             s << decl->name() << "::";
         s << func->signatureComment() << '\n';
     }
@@ -3184,8 +2901,9 @@ void CppGenerator::writeOverloadedFunctionDecisor(TextStream &s, const OverloadD
     }
 
     s << "// Function signature not found.\n"
-        << "if (overloadId == -1) goto "
-        << cpythonFunctionName(overloadData.referenceFunction()) << "_TypeError;\n\n";
+        << "if (overloadId == -1)\n" << indent
+            << "return " << returnErrorWrongArguments(overloadData, errorReturn) << ";\n\n"
+            << outdent;
 }
 
 void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
@@ -3251,7 +2969,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
         auto func = referenceFunction;
         for (const auto &child : children) {
             const auto defValFunc = child->getFunctionWithDefaultValue();
-            if (!defValFunc.isNull()) {
+            if (defValFunc) {
                 func = defValFunc;
                 break;
             }
@@ -3277,7 +2995,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
         int sequenceArgCount = 0;
         while (od && !od->argType().isVarargs()) {
             const bool typeReplacedByPyObject = od->isTypeModified()
-                && od->modifiedArgType().name() == cPyObjectT();
+                && od->modifiedArgType().name() == cPyObjectT;
             if (!typeReplacedByPyObject) {
                 if (usePyArgs)
                     pyArgName = pythonArgsAt(od->argPos());
@@ -3285,7 +3003,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
                 auto func = od->referenceFunction();
 
                 if (func->isConstructor() && func->arguments().size() == 1) {
-                    const AbstractMetaClass *ownerClass = func->ownerClass();
+                    AbstractMetaClassCPtr ownerClass = func->ownerClass();
                     ComplexTypeEntryCPtr baseContainerType = ownerClass->typeEntry()->baseContainerType();
                     if (baseContainerType && baseContainerType == func->arguments().constFirst().type().typeEntry()
                         && ownerClass->isCopyable()) {
@@ -3341,7 +3059,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
             s << indent << typeChecks.join(u"\n&& "_s) << outdent;
         }
         s << ") {\n" << indent;
-        writeOverloadedFunctionDecisorEngine(s, overloadData, child.data());
+        writeOverloadedFunctionDecisorEngine(s, overloadData, child.get());
         s << outdent << '}';
     }
     s << '\n';
@@ -3370,12 +3088,16 @@ void CppGenerator::writeFunctionCalls(TextStream &s, const OverloadData &overloa
 
 static void writeDeprecationWarning(TextStream &s,
                                     const GeneratorContext &context,
-                                    const AbstractMetaFunctionCPtr &func)
+                                    const AbstractMetaFunctionCPtr &func,
+                                    CppGenerator::ErrorReturn errorReturn)
 {
     s << "Shiboken::Warnings::warnDeprecated(\"";
-    if (auto *cls = context.metaClass())
+    if (const auto cls = context.metaClass())
         s << cls->name() << "\", ";
-    s << '"' << func->signature().replace(u"::"_s, u"."_s) << "\");\n";
+    // Check error in case "warning-as-error" is set.
+    s << '"' << func->signature().replace(u"::"_s, u"."_s) << "\");\n"
+        << "if (" << shibokenErrorsOccurred << ")\n"
+        << indent << errorReturn << outdent;
 }
 
 void CppGenerator::writeSingleFunctionCall(TextStream &s,
@@ -3385,7 +3107,7 @@ void CppGenerator::writeSingleFunctionCall(TextStream &s,
                                            ErrorReturn errorReturn) const
 {
     if (func->isDeprecated())
-        writeDeprecationWarning(s, context, func);
+        writeDeprecationWarning(s, context, func, errorReturn);
 
     if (func->functionType() == AbstractMetaFunction::EmptyFunction) {
         s << "Shiboken::Errors::setPrivateMethod(\""
@@ -3397,7 +3119,7 @@ void CppGenerator::writeSingleFunctionCall(TextStream &s,
     const bool usePyArgs = overloadData.pythonFunctionWrapperUsesListOfArguments();
 
     // Handle named arguments.
-    writeNamedArgumentResolution(s, func, usePyArgs, overloadData);
+    writeNamedArgumentResolution(s, func, usePyArgs, overloadData, errorReturn);
 
     bool injectCodeCallsFunc = injectedCodeCallsCppFunction(context, func);
     bool mayHaveUnunsedArguments = !func->isUserAdded() && func->hasInjectedCode() && injectCodeCallsFunc;
@@ -3411,8 +3133,7 @@ void CppGenerator::writeSingleFunctionCall(TextStream &s,
         const AbstractMetaArgument &arg = func->arguments().at(argIdx);
         if (arg.isModifiedRemoved()) {
             if (!arg.defaultValueExpression().isEmpty()) {
-                const QString cppArgRemoved = CPP_ARG_REMOVED
-                    + QString::number(argIdx);
+                const QString cppArgRemoved = CPP_ARG_REMOVED(argIdx);
                 s << getFullTypeName(arg.type()) << ' ' << cppArgRemoved;
                 s << " = " << arg.defaultValueExpression() << ";\n"
                     << sbkUnusedVariableCast(cppArgRemoved);
@@ -3434,10 +3155,9 @@ void CppGenerator::writeSingleFunctionCall(TextStream &s,
             continue;
         auto argType = getArgumentType(func, argIdx);
         int argPos = argIdx - removedArgs;
-        QString argName = CPP_ARG + QString::number(argPos);
         QString pyArgName = usePyArgs ? pythonArgsAt(argPos) : PYTHON_ARG;
         indirections[argIdx] =
-            writeArgumentConversion(s, argType, argName, pyArgName, errorReturn,
+            writeArgumentConversion(s, argType, CPP_ARG_N(argPos), pyArgName, errorReturn,
                                     func->implementingClass(), arg.defaultValueExpression(),
                                     func->isUserAdded());
     }
@@ -3446,7 +3166,7 @@ void CppGenerator::writeSingleFunctionCall(TextStream &s,
 
     int numRemovedArgs = OverloadData::numberOfRemovedArguments(func);
 
-    s << "if (!PyErr_Occurred()) {\n" << indent;
+    s << "if (Shiboken::Errors::occurred() == nullptr) {\n" << indent;
     writeMethodCall(s, func, context,
                     overloadData.pythonFunctionWrapperUsesListOfArguments(),
                     func->arguments().size() - numRemovedArgs, indirections, errorReturn);
@@ -3497,9 +3217,10 @@ void CppGenerator::writeCppToPythonFunction(TextStream &s, const QString &code,
 {
 
     QString prettyCode = code;
-    processCodeSnip(prettyCode);
+    const QString funcName = cppToPythonFunctionName(sourceTypeName, targetTypeName);
+    processCodeSnip(prettyCode, funcName);
 
-    s << "static PyObject *" << cppToPythonFunctionName(sourceTypeName, targetTypeName)
+    s << "static PyObject *" << funcName
         << "(const void *cppIn)\n{\n" << indent << prettyCode
         << ensureEndl << outdent << "}\n";
 }
@@ -3537,10 +3258,22 @@ void CppGenerator::writeCppToPythonFunction(TextStream &s,
     replaceCppToPythonVariables(code, getFullTypeName(ownerType), constRef);
     writeCppToPythonFunction(s, code, fixedCppTypeName(customConversion->ownerType()));
 }
+
+QString CppGenerator::containerNativeToTargetTypeName(const ContainerTypeEntryCPtr &type)
+{
+    QString result = type->targetLangApiName();
+    if (result != cPyObjectT) {
+        result = containerCpythonBaseName(type);
+        if (result == cPySequenceT)
+            result = cPyListT;
+    }
+    return result;
+}
+
 void CppGenerator::writeCppToPythonFunction(TextStream &s, const AbstractMetaType &containerType) const
 {
     Q_ASSERT(containerType.typeEntry()->isContainer());
-    auto cte = qSharedPointerCast<const ContainerTypeEntry>(containerType.typeEntry());
+    auto cte = std::static_pointer_cast<const ContainerTypeEntry>(containerType.typeEntry());
     if (!cte->hasCustomConversion()) {
         QString m;
         QTextStream(&m) << "Can't write the C++ to Python conversion function for container type '"
@@ -3558,16 +3291,18 @@ void CppGenerator::writeCppToPythonFunction(TextStream &s, const AbstractMetaTyp
         code.replace(u"%INTYPE_"_s + QString::number(i), typeName);
     }
     replaceCppToPythonVariables(code, getFullTypeNameWithoutModifiers(containerType), true);
-    processCodeSnip(code);
-    writeCppToPythonFunction(s, code, fixedCppTypeName(containerType));
+    processCodeSnip(code, containerType.typeEntry()->qualifiedCppName());
+    writeCppToPythonFunction(s, code, fixedCppTypeName(containerType),
+                             containerNativeToTargetTypeName(cte));
 }
 
 void CppGenerator::writePythonToCppFunction(TextStream &s, const QString &code, const QString &sourceTypeName,
                                             const QString &targetTypeName) const
 {
     QString prettyCode = code;
-    processCodeSnip(prettyCode);
-    s << "static void " << pythonToCppFunctionName(sourceTypeName, targetTypeName)
+    const QString funcName = pythonToCppFunctionName(sourceTypeName, targetTypeName);
+    processCodeSnip(prettyCode, funcName);
+    s << "static void " << funcName
         << "(PyObject *pyIn, void *cppOut)\n{\n" << indent << prettyCode
         << ensureEndl << outdent << "}\n";
 }
@@ -3589,7 +3324,7 @@ void CppGenerator::writeIsPythonConvertibleToCppFunction(TextStream &s,
             << "return Shiboken::Conversions::nonePythonToCppNullPtr;\n" << outdent;
     } else {
         if (!condition.contains(u"pyIn"))
-            s << sbkUnusedVariableCast(u"pyIn"_s);
+            s << sbkUnusedVariableCast("pyIn");
     }
     s << "if (" << condition << ")\n" << indent
         << "return " << pythonToCppFuncName << ";\n" << outdent
@@ -3656,8 +3391,6 @@ void CppGenerator::writePythonToCppConversionFunctions(TextStream &s,
         QString pyTypeName = toNative.sourceTypeName();
         if (pyTypeName == u"Py_None" || pyTypeName == u"PyNone")
             typeCheck = u"%in == Py_None"_s;
-        else if (pyTypeName == u"SbkEnumType")
-            typeCheck = u"Shiboken::isShibokenEnum(%in)"_s;
         else if (pyTypeName == u"SbkObject")
             typeCheck = u"Shiboken::Object::checkType(%in)"_s;
     }
@@ -3672,29 +3405,26 @@ void CppGenerator::writePythonToCppConversionFunctions(TextStream &s,
                     + cpythonTypeNameExt(toNative.sourceType()) + u')';
     }
     typeCheck.replace(u"%in"_s, u"pyIn"_s);
-    processCodeSnip(typeCheck);
+    processCodeSnip(typeCheck, targetType->qualifiedCppName());
     writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, typeCheck);
 }
 
 void CppGenerator::writePythonToCppConversionFunctions(TextStream &s, const AbstractMetaType &containerType) const
 {
     Q_ASSERT(containerType.typeEntry()->isContainer());
-    auto cte = qSharedPointerCast<const ContainerTypeEntry>(containerType.typeEntry());
-    if (!cte->hasCustomConversion()) {
-        //qFatal
-        return;
-    }
-
+    const auto cte = std::static_pointer_cast<const ContainerTypeEntry>(containerType.typeEntry());
     const auto customConversion = cte->customConversion();
-    const TargetToNativeConversions &toCppConversions =
-        customConversion->targetToNativeConversions();
-    if (toCppConversions.isEmpty()) {
-        //qFatal
-        return;
-    }
+    for (const auto &conv : customConversion->targetToNativeConversions())
+        writePythonToCppConversionFunction(s, containerType, conv);
+}
+
+void CppGenerator::writePythonToCppConversionFunction(TextStream &s,
+                                                      const AbstractMetaType &containerType,
+                                                      const TargetToNativeConversion &conv) const
+{
     // Python to C++ conversion function.
     QString cppTypeName = getFullTypeNameWithoutModifiers(containerType);
-    QString code = toCppConversions.constFirst().conversion();
+    QString code = conv.conversion();
     const QString line = u"auto &cppOutRef = *reinterpret_cast<"_s
         + cppTypeName + u" *>(cppOut);"_s;
     CodeSnipAbstract::prependCode(&code, line);
@@ -3722,7 +3452,8 @@ void CppGenerator::writePythonToCppConversionFunctions(TextStream &s, const Abst
     code.replace(u"%in"_s, u"pyIn"_s);
     code.replace(u"%out"_s, u"cppOutRef"_s);
     QString typeName = fixedCppTypeName(containerType);
-    writePythonToCppFunction(s, code, typeName, typeName);
+    const QString &sourceTypeName = conv.sourceTypeName();
+    writePythonToCppFunction(s, code, sourceTypeName, typeName);
 
     // Python to C++ convertible check function.
     QString typeCheck = cpythonCheckFunction(containerType);
@@ -3730,7 +3461,7 @@ void CppGenerator::writePythonToCppConversionFunctions(TextStream &s, const Abst
         typeCheck = u"false"_s;
     else
         typeCheck = typeCheck + u"pyIn)"_s;
-    writeIsPythonConvertibleToCppFunction(s, typeName, typeName, typeCheck);
+    writeIsPythonConvertibleToCppFunction(s, sourceTypeName, typeName, typeCheck);
     s << '\n';
 }
 
@@ -3771,17 +3502,20 @@ static bool forceQObjectNamedArguments(const AbstractMetaFunctionCPtr &func)
 {
     if (func->functionType() != AbstractMetaFunction::ConstructorFunction)
         return false;
-    auto *owner = func->ownerClass();
+    const auto owner = func->ownerClass();
     Q_ASSERT(owner);
-    if (!owner->isQObject())
+    if (!isQObject(owner))
         return false;
     const QString &name = owner->name();
     return name == u"QVBoxLayout" || name == u"QHBoxLayout"
         || name == u"QSplitterHandle" || name == u"QSizeGrip";
 }
 
-void CppGenerator::writeNamedArgumentResolution(TextStream &s, const AbstractMetaFunctionCPtr &func,
-                                                bool usePyArgs, const OverloadData &overloadData) const
+void CppGenerator::writeNamedArgumentResolution(TextStream &s,
+                                                const AbstractMetaFunctionCPtr &func,
+                                                bool usePyArgs,
+                                                const OverloadData &overloadData,
+                                                ErrorReturn errorReturn)
 {
     const AbstractMetaArgumentList &args = OverloadData::getArgumentsWithDefaultValues(func);
     const bool hasDefaultArguments = !args.isEmpty();
@@ -3790,10 +3524,10 @@ void CppGenerator::writeNamedArgumentResolution(TextStream &s, const AbstractMet
     if (!hasDefaultArguments && !force) {
         if (overloadData.hasArgumentWithDefaultValue()) {
             // PySide-535: Allow for empty dict instead of nullptr in PyPy
-            s << "if (kwds && PyDict_Size(kwds) > 0) {\n" << indent
+            s << "if (kwds != nullptr && PyDict_Size(kwds) > 0) {\n" << indent
                 << "errInfo.reset(kwds);\n"
                 << "Py_INCREF(errInfo.object());\n"
-                << "goto " << cpythonFunctionName(func) << "_TypeError;\n"
+                << "return " << returnErrorWrongArguments(overloadData, errorReturn) << ";\n"
                 << outdent << "}\n";
         }
         return;
@@ -3812,19 +3546,19 @@ void CppGenerator::writeNamedArgumentResolution(TextStream &s, const AbstractMet
         QString pyKeyName = u"key_"_s + arg.name();
         s << "static PyObject *const " << pyKeyName
             << " = Shiboken::String::createStaticString(\"" << arg.name() << "\");\n"
-            << "if (PyDict_Contains(kwds, " << pyKeyName << ")) {\n" << indent
+            << "if (PyDict_Contains(kwds, " << pyKeyName << ") != 0) {\n" << indent
             << "value = PyDict_GetItem(kwds, " << pyKeyName << ");\n"
-            << "if (value && " << pyArgName << ") {\n" << indent
-            << "errInfo.reset(" << pyKeyName << ");\n"
+            << "if (value != nullptr && " << pyArgName << " != nullptr ) {\n"
+            << indent << "errInfo.reset(" << pyKeyName << ");\n"
             << "Py_INCREF(errInfo.object());\n"
-            << "goto " << cpythonFunctionName(func) << "_TypeError;\n"
-            << outdent << "}\nif (value) {\n" << indent
+            << "return " << returnErrorWrongArguments(overloadData, errorReturn) << ";\n"
+            << outdent << "}\nif (value != nullptr) {\n" << indent
             << pyArgName << " = value;\nif (!";
         const auto &type = arg.modifiedType();
         writeTypeCheck(s, type, pyArgName, isNumber(type.typeEntry()), {});
         s << ")\n" << indent
-            << "goto " << cpythonFunctionName(func) << "_TypeError;\n" << outdent
-            << outdent
+            << "return " << returnErrorWrongArguments(overloadData, errorReturn) << ";\n"
+            << outdent << outdent
             << "}\nPyDict_DelItem(kwds_dup, " << pyKeyName << ");\n"
             << outdent << "}\n";
     }
@@ -3834,8 +3568,8 @@ void CppGenerator::writeNamedArgumentResolution(TextStream &s, const AbstractMet
     // until extra keyword signals and properties are handled.
     s << "if (PyDict_Size(kwds_dup) > 0) {\n" << indent
         << "errInfo.reset(kwds_dup.release());\n";
-    if (!(func->isConstructor() && func->ownerClass()->isQObject()))
-        s << "goto " << cpythonFunctionName(func) << "_TypeError;\n";
+    if (!(func->isConstructor() && isQObject(func->ownerClass())))
+        s << "return " << returnErrorWrongArguments(overloadData, errorReturn) << ";\n";
     else
         s << "// fall through to handle extra keyword signals and properties\n";
     s << outdent << "}\n"
@@ -3847,7 +3581,7 @@ QString CppGenerator::argumentNameFromIndex(const ApiExtractorResult &api,
 {
     switch (argIndex) {
     case -1:
-        return u"self"_s;
+        return PYTHON_SELF_VAR;
     case 0:
         return PYTHON_RETURN_VAR;
     case 1: { // Single argument?
@@ -3860,7 +3594,7 @@ QString CppGenerator::argumentNameFromIndex(const ApiExtractorResult &api,
     return pythonArgsAt(argIndex - 1);
 }
 
-const AbstractMetaClass *
+AbstractMetaClassCPtr
 CppGenerator::argumentClassFromIndex(const ApiExtractorResult &api,
                                      const AbstractMetaFunctionCPtr &func, int argIndex)
 {
@@ -3885,7 +3619,7 @@ CppGenerator::argumentClassFromIndex(const ApiExtractorResult &api,
     auto te = type.typeEntry();
     if (type.isVoid() || !te->isComplex())
         throw Exception(msgInvalidArgumentModification(func, argIndex));
-    auto *result = AbstractMetaClass::findClass(api.classes(), te);
+    const auto result = AbstractMetaClass::findClass(api.classes(), te);
     if (!result)
         throw Exception(msgClassNotFound(te));
     return result;
@@ -3911,6 +3645,11 @@ if (errorType != nullptr)
     PyErr_SetObject(errorType, errorString);
 )";
 
+static QString explicitConversion(const QString &v, const AbstractMetaType &t)
+{
+    return t.plainType().cppSignature() + u'(' + v + u')';
+}
+
 void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr &func,
                                    const GeneratorContext &context, bool usesPyArgs,
                                    int maxArgs,
@@ -3984,7 +3723,7 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
                     if (hasConversionRule)
                         userArgs << arg.name() + CONV_RULE_OUT_VAR_SUFFIX;
                     else if (!arg.defaultValueExpression().isEmpty())
-                        userArgs.append(CPP_ARG_REMOVED + QString::number(i));
+                        userArgs.append(CPP_ARG_REMOVED(i));
                 } else {
                     if (hasConversionRule) {
                         userArgs.append(arg.name() + CONV_RULE_OUT_VAR_SUFFIX);
@@ -3992,14 +3731,16 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
                         const int idx = arg.argumentIndex() - removedArgs;
                         const auto deRef = argumentIndirections.at(i);
                         QString argName = AbstractMetaType::dereferencePrefix(deRef)
-                                          + CPP_ARG + QString::number(idx);
+                                          + CPP_ARG_N(idx);
                         userArgs.append(argName);
                     }
                 }
                 // "Pass unique ptr by value" pattern: Apply std::move()
                 auto type = arg.type();
-                if (type.isUniquePointer() && type.passByValue())
+                if (type.useStdMove())
                     userArgs.last() = stdMove(userArgs.constLast());
+                else if (type.viewOn() != nullptr)
+                    userArgs.last() = explicitConversion(userArgs.constLast(), type);
             }
 
             // If any argument's default value was modified the method must be called
@@ -4021,7 +3762,7 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
                 if (hasConversionRule)
                     otherArgs.prepend(arg.name() + CONV_RULE_OUT_VAR_SUFFIX);
                 else
-                    otherArgs.prepend(CPP_ARG_REMOVED + QString::number(i));
+                    otherArgs.prepend(CPP_ARG_REMOVED(i));
             }
             if (otherArgsModified)
                 userArgs << otherArgs;
@@ -4069,21 +3810,21 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
                 Q_ASSERT(owner == context.metaClass());
                 if (func->functionType() == AbstractMetaFunction::CopyConstructorFunction
                     && maxArgs == 1) {
-                    mc << "new ::" << context.effectiveClassName()
+                    mc << "new " << globalScopePrefix(context) << context.effectiveClassName()
                         << "(*" << CPP_ARG0 << ')';
                 } else {
                     const QString ctorCall = context.effectiveClassName() + u'('
                                              + userArgs.join(u", "_s) + u')';
-                    if (usePySideExtensions() && owner->isQObject()) {
+                    if (usePySideExtensions() && isQObject(owner)) {
                         s << "void *addr = PySide::nextQObjectMemoryAddr();\n";
-                        uva << "if (addr) {\n" << indent
-                            << "cptr = new (addr) ::" << ctorCall << ";\n"
-                            << "PySide::setNextQObjectMemoryAddr(nullptr);\n" << outdent
+                        uva << "if (addr != nullptr) {\n" << indent
+                            << "cptr = new (addr) " << globalScopePrefix(context) << ctorCall
+                            << ";\nPySide::setNextQObjectMemoryAddr(nullptr);\n" << outdent
                             << "} else {\n" << indent
-                            << "cptr = new ::" << ctorCall << ";\n"
+                            << "cptr = new " << globalScopePrefix(context) << ctorCall << ";\n"
                             << outdent << "}\n";
                     } else {
-                        mc << "new ::" << ctorCall;
+                        mc << "new " << globalScopePrefix(context) << ctorCall;
                     }
                 }
             } else {
@@ -4097,7 +3838,7 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
                     const bool hasWrapper = shouldGenerateCppWrapper(ownerClass);
                     if (!avoidProtectedHack() || !func->isProtected() || !hasWrapper) {
                         if (func->isStatic()) {
-                            mc << "::" << methodCallClassName << "::";
+                            mc << m_gsp << methodCallClassName << "::";
                         } else {
                             const QString cppSelfVar = CPP_SELF_VAR;
                             const QString selfVarCast = func->ownerClass() == func->implementingClass()
@@ -4106,7 +3847,7 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
                                   + u" *>("_s + cppSelfVar + u')';
                             if (func->isConstant()) {
                                 if (avoidProtectedHack()) {
-                                    mc << "const_cast<const ::";
+                                    mc << "const_cast<const " << globalScopePrefix(context);
                                     if (ownerClass->cppWrapper().testFlag(AbstractMetaClass::CppProtectedHackWrapper)) {
                                         // PYSIDE-500: Need a special wrapper cast when inherited
                                         const QString selfWrapCast = ownerClass == func->implementingClass()
@@ -4121,7 +3862,7 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
                                         mc << " *>(" << selfVarCast << ")->";
                                     }
                                 } else {
-                                    mc << "const_cast<const ::" << methodCallClassName;
+                                    mc << "const_cast<const " << m_gsp << methodCallClassName;
                                     mc <<  " *>(" << selfVarCast << ")->";
                                 }
                             } else {
@@ -4137,13 +3878,13 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
                         if (!func->isStatic()) {
                             const bool directInheritance = context.metaClass() == ownerClass;
                             mc << (directInheritance ? "static_cast" : "reinterpret_cast")
-                                << "<::" << wrapperName(ownerClass) << " *>(" << CPP_SELF_VAR << ")->";
+                               << '<' << wrapperName(ownerClass) << " *>("
+                               << CPP_SELF_VAR << ")->";
                         }
 
                         if (!func->isAbstract())
                             mc << (func->isProtected() ? wrapperName(func->ownerClass()) :
-                                                         u"::"_s
-                                                         + methodCallClassName) << "::";
+                                                         m_gsp + methodCallClassName) << "::";
                         mc << func->originalName() << "_protected";
                     }
                 } else {
@@ -4294,8 +4035,8 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
             s << "Shiboken::Object::";
             if (ownership == TypeSystem::TargetLangOwnership) {
                 s << "getOwnership(" << pyArgName << ");";
-            } else if (auto *ac = argumentClassFromIndex(api(), func, argIndex);
-                       ac->hasVirtualDestructor()) {
+            } else if (auto ac = argumentClassFromIndex(api(), func, argIndex);
+                       ac && ac->hasVirtualDestructor()) {
                 s << "releaseOwnership(" << pyArgName << ");";
             } else {
                 s << "invalidate(" << pyArgName << ");";
@@ -4340,12 +4081,12 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
         s << propagateException;
 }
 
-QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass *metaClass)
+QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClassCPtr &metaClass)
 {
     QStringList result;
     const auto &baseClases = metaClass->typeSystemBaseClasses();
     if (!baseClases.isEmpty()) {
-        for (const AbstractMetaClass *baseClass : baseClases) {
+        for (const auto &baseClass : baseClases) {
             QString offset;
             QTextStream(&offset) << "reinterpret_cast<uintptr_t>(static_cast<const "
                 << baseClass->qualifiedCppName() << " *>(class_ptr)) - base";
@@ -4358,50 +4099,55 @@ QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass
             result.append(offset);
         }
 
-        for (const AbstractMetaClass *baseClass : baseClases)
+        for (const auto &baseClass : baseClases)
             result.append(getAncestorMultipleInheritance(baseClass));
     }
     return result;
 }
 
-void CppGenerator::writeMultipleInheritanceInitializerFunction(TextStream &s, const AbstractMetaClass *metaClass)
+void CppGenerator::writeMultipleInheritanceInitializerFunction(TextStream &s,
+                                                               const AbstractMetaClassCPtr &metaClass)
 {
     QString className = metaClass->qualifiedCppName();
     const QStringList ancestors = getAncestorMultipleInheritance(metaClass);
-    s << "static int mi_offsets[] = { ";
-    for (qsizetype i = 0; i < ancestors.size(); i++)
-        s << "-1, ";
-    s << "-1 };\n"
-        << "int *\n"
+    s  << "int *\n"
         << multipleInheritanceInitializerFunctionName(metaClass) << "(const void *cptr)\n"
-        << "{\n" << indent
-        << "if (mi_offsets[0] == -1) {\n" << indent
-        << "std::set<int> offsets;\n"
-            << "const auto *class_ptr = reinterpret_cast<const " << className << " *>(cptr);\n"
-            << "const auto base = reinterpret_cast<uintptr_t>(class_ptr);\n";
+        << "{\n" << indent;
+    s << "static int mi_offsets[] = {-2";
+    for (qsizetype i = 0; i < ancestors.size(); i++)
+        s << ", 0";
+    s << "};\n"
+        << "if (mi_offsets[0] == -2) {\n" << indent
+        << "const auto *class_ptr = reinterpret_cast<const " << className << " *>(cptr);\n"
+        << "const auto base = reinterpret_cast<uintptr_t>(class_ptr);\n"
+        << "int *p = mi_offsets;\n";
 
     for (const QString &ancestor : ancestors)
-        s << "offsets.insert(int(" << ancestor << "));\n";
-
-    s << "\noffsets.erase(0);\n\n"
-        << "std::copy(offsets.cbegin(), offsets.cend(), mi_offsets);\n" << outdent
+        s << "*p++ = int(" << ancestor << ");\n";
+    s << "std::sort(mi_offsets, p);\n"
+        << "auto *end = std::unique(mi_offsets, p);\n"
+        << "*end++ = -1;\n"
+        << "if (mi_offsets[0] == 0)\n"
+        << indent
+        << "std::memmove(&mi_offsets[0], &mi_offsets[1], (end - mi_offsets  - 1) * sizeof(int));\n"
+        << outdent << outdent
         << "}\nreturn mi_offsets;\n" << outdent << "}\n";
 }
 
-void CppGenerator::writeSpecialCastFunction(TextStream &s, const AbstractMetaClass *metaClass)
+void CppGenerator::writeSpecialCastFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass)
 {
     QString className = metaClass->qualifiedCppName();
     s << "static void * " << cpythonSpecialCastFunctionName(metaClass)
         << "(void *obj, PyTypeObject *desiredType)\n{\n" << indent
-        << "auto me = reinterpret_cast< ::" << className << " *>(obj);\n";
+        << "auto me = reinterpret_cast< " << m_gsp << className << " *>(obj);\n";
     bool firstClass = true;
     const auto &allAncestors = metaClass->allTypeSystemAncestors();
-    for (const AbstractMetaClass *baseClass : allAncestors) {
+    for (const auto &baseClass : allAncestors) {
         if (!firstClass)
             s << "else ";
         s << "if (desiredType == " << cpythonTypeNameExt(baseClass->typeEntry())
             << ")\n" << indent
-            << "return static_cast< ::" << baseClass->qualifiedCppName() << " *>(me);\n"
+            << "return static_cast< " << getFullTypeName(baseClass) << " *>(me);\n"
             << outdent;
         firstClass = false;
     }
@@ -4417,79 +4163,28 @@ void CppGenerator::writePrimitiveConverterInitialization(TextStream &s,
         << converter << " = Shiboken::Conversions::createConverter(";
     if (!type->hasTargetLangApiType())
         s << "nullptr";
-    else if (type->targetLangApiName() == cPyObjectT())
+    else if (type->targetLangApiName() == cPyObjectT)
         s << "&PyBaseObject_Type";
     else
         s << '&' << type->targetLangApiName() << "_Type";
     QString typeName = fixedCppTypeName(type);
     s << ", " << cppToPythonFunctionName(typeName, typeName) << ");\n"
-        << "Shiboken::Conversions::registerConverterName(" << converter << ", \""
-        << type->qualifiedCppName() << "\");\n";
+        << registerConverterName(type->qualifiedCppName(), converter);
     writeCustomConverterRegister(s, customConversion, converter);
 }
 
-static void registerEnumConverterScopes(TextStream &s, QString signature)
+static void registerConverterInScopes(TextStream &s, QStringView signature,
+                                      QAnyStringView varName = converterVar)
 {
     while (true) {
-        s << "Shiboken::Conversions::registerConverterName(converter, \""
-          << signature << "\");\n";
-        const int qualifierPos = signature.indexOf(u"::");
-        if (qualifierPos != -1)
-            signature.remove(0, qualifierPos + 2);
-        else
+        s << registerConverterName(signature, varName);
+        const auto qualifierPos = signature.indexOf("::"_L1);
+        if (qualifierPos == -1)
             break;
+        signature = signature.sliced(qualifierPos + 2);
     }
 }
 
-void CppGenerator::writeFlagsConverterInitialization(TextStream &s,
-                                                     const FlagsTypeEntryCPtr &flags)
-{
-    static const char enumPythonVar[] = "FType";
-
-    const QString qualifiedCppName = flags->qualifiedCppName();
-    s << "// Register converter for flag '" << qualifiedCppName << "'.\n{\n"
-        << indent;
-    QString typeName = fixedCppTypeName(flags);
-    s << "SbkConverter *converter = Shiboken::Conversions::createConverter("
-        << enumPythonVar << ',' << '\n' << indent
-        << cppToPythonFunctionName(typeName, typeName) << ");\n" << outdent;
-
-    const QString enumTypeName = fixedCppTypeName(flags->originator());
-    QString toCpp = pythonToCppFunctionName(enumTypeName, typeName);
-    QString isConv = convertibleToCppFunctionName(enumTypeName, typeName);
-    writeAddPythonToCppConversion(s, u"converter"_s, toCpp, isConv);
-    toCpp = pythonToCppFunctionName(typeName, typeName);
-    isConv = convertibleToCppFunctionName(typeName, typeName);
-    writeAddPythonToCppConversion(s, u"converter"_s, toCpp, isConv);
-    toCpp = pythonToCppFunctionName(u"number"_s, typeName);
-    isConv = convertibleToCppFunctionName(u"number"_s, typeName);
-    writeAddPythonToCppConversion(s, u"converter"_s, toCpp, isConv);
-    s << "Shiboken::Enum::setTypeConverter(" << enumPythonVar
-        << ", converter, true);\n";
-    // Replace "QFlags<Class::Option>" by "Class::Options"
-    QString signature = qualifiedCppName;
-    if (qualifiedCppName.startsWith(u"QFlags<") && qualifiedCppName.endsWith(u'>')) {
-        signature.chop(1);
-        signature.remove(0, 7);
-        const int lastQualifierPos = signature.lastIndexOf(u"::");
-        if (lastQualifierPos != -1) {
-            signature.replace(lastQualifierPos + 2, signature.size() - lastQualifierPos - 2,
-                              flags->flagsName());
-        } else {
-            signature = flags->flagsName();
-        }
-    }
-
-    registerEnumConverterScopes(s, signature);
-
-    // PYSIDE-1673: Also register "QFlags<Class::Option>" purely for
-    // the purpose of finding the converter by QVariant::typeName()
-    // in the QVariant conversion code.
-    s << "Shiboken::Conversions::registerConverterName(converter, \""
-        << flags->name() << "\");\n"
-        << outdent << "}\n";
-}
-
 void CppGenerator::writeEnumConverterInitialization(TextStream &s, const AbstractMetaEnum &metaEnum)
 {
     if (metaEnum.isPrivate() || metaEnum.isAnonymous())
@@ -4511,81 +4206,71 @@ void CppGenerator::writeEnumConverterInitialization(TextStream &s, const Abstrac
     const QString isConv = convertibleToCppFunctionName(typeName, typeName);
     writeAddPythonToCppConversion(s, u"converter"_s, toCpp, isConv);
     s << "Shiboken::Enum::setTypeConverter(" << enumPythonVar
-        << ", converter, false);\n";
+        << ", converter);\n";
 
-    registerEnumConverterScopes(s, enumType->qualifiedCppName());
+    registerConverterInScopes(s, enumType->qualifiedCppName());
+    if (auto flags = enumType->flags())
+        s << "// Register converter for flag '" << flags->qualifiedCppName() << "'.\n"
+            << registerConverterName(flags->name()) // QMetaType
+            << registerConverterName(flags->originalName()); // Signals with flags
 
     s << outdent << "}\n";
-
-    if (auto flags = enumType->flags(); !flags.isNull())
-        writeFlagsConverterInitialization(s, flags);
 }
 
-QString CppGenerator::writeContainerConverterInitialization(TextStream &s, const AbstractMetaType &type) const
+QString CppGenerator::writeContainerConverterInitialization(TextStream &s,
+                                                            const AbstractMetaType &type,
+                                                            const ApiExtractorResult &api)
 {
-    QByteArray cppSignature = QMetaObject::normalizedSignature(type.cppSignature().toUtf8());
+    const auto cppSignature =
+        QString::fromUtf8(QMetaObject::normalizedSignature(type.cppSignature().toUtf8()));
     s << "// Register converter for type '" << cppSignature << "'.\n";
-    QString converter = converterObject(type);
+    const QString converter = converterObject(type);
     s << converter << " = Shiboken::Conversions::createConverter(";
-    if (type.typeEntry()->targetLangApiName() == cPyObjectT()) {
+
+    Q_ASSERT(type.typeEntry()->isContainer());
+    const auto typeEntry = std::static_pointer_cast<const ContainerTypeEntry>(type.typeEntry());
+
+    const QString targetTypeName = containerNativeToTargetTypeName(typeEntry);
+    if (targetTypeName == cPyObjectT) {
         s << "&PyBaseObject_Type";
     } else {
-        QString baseName = cpythonBaseName(type.typeEntry());
-        if (baseName == cPySequenceT())
-            baseName = cPyListT();
-        s << '&' << baseName << "_Type";
-    }
-    QString typeName = fixedCppTypeName(type);
-    s << ", " << cppToPythonFunctionName(typeName, typeName) << ");\n";
-    QString toCpp = pythonToCppFunctionName(typeName, typeName);
-    QString isConv = convertibleToCppFunctionName(typeName, typeName);
-    s << "Shiboken::Conversions::registerConverterName(" << converter << ", \"" << cppSignature << "\");\n";
-    if (usePySideExtensions() && cppSignature.startsWith("const ") && cppSignature.endsWith("&")) {
-        cppSignature.chop(1);
-        cppSignature.remove(0, sizeof("const ") / sizeof(char) - 1);
-        s << "Shiboken::Conversions::registerConverterName(" << converter << ", \"" << cppSignature << "\");\n";
+        s << '&' << targetTypeName << "_Type";
     }
-    const QString converterObj = converterObject(type);
-    writeAddPythonToCppConversion(s, converterObj, toCpp, isConv);
-    return converterObj;
-}
 
-void CppGenerator::writeSmartPointerConverterInitialization(TextStream &s, const AbstractMetaType &type) const
-{
-    const QByteArray cppSignature = type.cppSignature().toUtf8();
-    auto writeConversionRegister = [&s](const AbstractMetaType &sourceType, const QString &targetTypeName, const QString &targetConverter)
-    {
-        const QString sourceTypeName = fixedCppTypeName(sourceType);
-        const QString toCpp = pythonToCppFunctionName(sourceTypeName, targetTypeName);
-        const QString isConv = convertibleToCppFunctionName(sourceTypeName, targetTypeName);
-
-        writeAddPythonToCppConversion(s, targetConverter, toCpp, isConv);
-    };
-
-    const auto classes = findSmartPointeeBaseClasses(api(), type);
-    if (classes.isEmpty())
-        return;
+    const QString typeName = fixedCppTypeName(type);
+    s << ", " << cppToPythonFunctionName(typeName, targetTypeName) << ");\n";
 
-    auto smartPointerTypeEntry = qSharedPointerCast<const SmartPointerTypeEntry>(type.typeEntry());
+    s << registerConverterName(cppSignature, converter);
+    if (usePySideExtensions() && cppSignature.startsWith("const "_L1)
+        && cppSignature.endsWith(u'&')) {
+        auto underlyingType = QStringView{cppSignature}.sliced(6, cppSignature.size() - 7);
+        s << registerConverterName(underlyingType, converter);
+    }
 
-    s << "// Register SmartPointer converter for type '" << cppSignature << "'." << '\n'
-       << "///////////////////////////////////////////////////////////////////////////////////////\n\n";
+    for (const auto &conv : typeEntry->customConversion()->targetToNativeConversions()) {
+        const QString &sourceTypeName = conv.sourceTypeName();
+        QString toCpp = pythonToCppFunctionName(sourceTypeName, typeName);
+        QString isConv = convertibleToCppFunctionName(sourceTypeName, typeName);
+        writeAddPythonToCppConversion(s, converter, toCpp, isConv);
+    }
 
-    for (auto *base : classes) {
-        auto baseTe = base->typeEntry();
-        if (auto opt = findSmartPointerInstantiation(smartPointerTypeEntry, baseTe)) {
-            const auto smartTargetType = opt.value();
-            s << "// Convert to SmartPointer derived class: ["
-                << smartTargetType.cppSignature() << "]\n";
-            const QString converter = u"Shiboken::Conversions::getConverter(\""_s
-                                      + smartTargetType.cppSignature() + u"\")"_s;
-            writeConversionRegister(type, fixedCppTypeName(smartTargetType), converter);
-        } else {
-            s << "// Class not found:" << type.instantiations().at(0).cppSignature();
+    auto typedefItPair = api.typedefTargetToName().equal_range(type.cppSignature());
+    if (typedefItPair.first != typedefItPair.second) {
+        auto *typeDb = TypeDatabase::instance();
+        s << "// Register converters for type aliases of " << cppSignature << "'.\n";
+        for (auto it = typedefItPair.first; it != typedefItPair.second; ++it) {
+            if (!typeDb->findType(it.value()))
+                s << registerConverterName(it.value(), converter);
         }
     }
 
-    s << "///////////////////////////////////////////////////////////////////////////////////////" << '\n' << '\n';
+    return converter;
+}
+
+QString CppGenerator::typeInitStruct(const TypeEntryCPtr &te)
+{
+    return cppApiVariableName(te->targetLangPackage()) + u'['
+        + getTypeIndexVariableName(te) + u']';
 }
 
 void CppGenerator::writeExtendedConverterInitialization(TextStream &s,
@@ -4594,23 +4279,23 @@ void CppGenerator::writeExtendedConverterInitialization(TextStream &s,
 {
     s << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName()
       << ".\n";
-    for (const AbstractMetaClass *sourceClass : conversions) {
-        const QString converterVar = cppApiVariableName(externalType->targetLangPackage()) + u'['
-            + getTypeIndexVariableName(externalType) + u']';
+    for (const auto &sourceClass : conversions) {
         QString sourceTypeName = fixedCppTypeName(sourceClass->typeEntry());
         QString targetTypeName = fixedCppTypeName(externalType);
         QString toCpp = pythonToCppFunctionName(sourceTypeName, targetTypeName);
         QString isConv = convertibleToCppFunctionName(sourceTypeName, targetTypeName);
-        writeAddPythonToCppConversion(s, converterVar, toCpp, isConv);
+        if (!externalType->isPrimitive())
+            s << cpythonTypeNameExt(externalType) << ";\n";
+        writeAddPythonToCppConversion(s, typeInitStruct(externalType), toCpp, isConv);
     }
 }
 
-QString CppGenerator::multipleInheritanceInitializerFunctionName(const AbstractMetaClass *metaClass)
+QString CppGenerator::multipleInheritanceInitializerFunctionName(const AbstractMetaClassCPtr &metaClass)
 {
     return cpythonBaseName(metaClass->typeEntry()) + u"_mi_init"_s;
 }
 
-bool CppGenerator::supportsMappingProtocol(const AbstractMetaClass *metaClass)
+bool CppGenerator::supportsMappingProtocol(const AbstractMetaClassCPtr &metaClass)
 {
     for (const auto &m : mappingProtocols()) {
         if (metaClass->hasFunction(m.name))
@@ -4620,7 +4305,7 @@ bool CppGenerator::supportsMappingProtocol(const AbstractMetaClass *metaClass)
     return false;
 }
 
-bool CppGenerator::supportsNumberProtocol(const AbstractMetaClass *metaClass) const
+bool CppGenerator::supportsNumberProtocol(const AbstractMetaClassCPtr &metaClass)
 {
     return metaClass->hasArithmeticOperatorOverload()
             || metaClass->hasIncDecrementOperatorOverload()
@@ -4629,7 +4314,7 @@ bool CppGenerator::supportsNumberProtocol(const AbstractMetaClass *metaClass) co
             || hasBoolCast(metaClass);
 }
 
-bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass *metaClass)
+bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClassCPtr &metaClass)
 {
     for (const auto &seq : sequenceProtocols()) {
         if (metaClass->hasFunction(seq.name))
@@ -4640,7 +4325,7 @@ bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass *metaClass)
     return baseType && baseType->isContainer();
 }
 
-bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClass *metaClass) const
+bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClassCPtr &metaClass)
 {
     for (const AbstractMetaField &f : metaClass->fields()) {
         if (!f.isStatic())
@@ -4658,29 +4343,24 @@ bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClass *metaClass)
 
 struct pyTypeSlotEntry
 {
-    explicit pyTypeSlotEntry(const char *name, const QString &function) :
+    explicit pyTypeSlotEntry(QAnyStringView name, QAnyStringView function) :
         m_name(name), m_function(function) {}
 
-    const char *m_name;
-    const QString &m_function;
+    QAnyStringView m_name;
+    QAnyStringView m_function;
 };
 
 TextStream &operator<<(TextStream &str, const pyTypeSlotEntry &e)
 {
-    str << '{' << e.m_name << ',';
-    const int padding = qMax(0, 18 - int(strlen(e.m_name)));
-    for (int p = 0; p < padding; ++p)
-        str << ' ';
-    if (e.m_function.isEmpty())
-        str << NULL_PTR;
-    else
-        str << "reinterpret_cast<void *>(" << e.m_function << ')';
-    str << "},\n";
+    if (!e.m_function.isEmpty()) {
+        str << '{' << e.m_name << ',' << Pad(' ', qMax(0, 18 - e.m_name.size()))
+            << "reinterpret_cast<void *>(" << e.m_function << ")},\n";
+    }
     return str;
 }
 
 void CppGenerator::writeClassDefinition(TextStream &s,
-                                        const AbstractMetaClass *metaClass,
+                                        const AbstractMetaClassCPtr &metaClass,
                                         const GeneratorContext &classContext)
 {
     QString tp_init;
@@ -4689,7 +4369,6 @@ void CppGenerator::writeClassDefinition(TextStream &s,
     QString tp_hash;
     QString tp_call;
     const QString className = chopType(cpythonTypeName(metaClass));
-    QString baseClassName;
     AbstractMetaFunctionCList ctors;
     const auto &allCtors = metaClass->queryFunctions(FunctionQueryOption::AnyConstructor);
     for (const auto &f : allCtors) {
@@ -4699,13 +4378,10 @@ void CppGenerator::writeClassDefinition(TextStream &s,
         }
     }
 
-    if (!metaClass->baseClass())
-        baseClassName = u"SbkObject_TypeF()"_s;
-
     bool onlyPrivCtor = !metaClass->hasNonPrivateConstructor();
 
     const bool isQApp = usePySideExtensions()
-        && metaClass->inheritsFrom(u"QCoreApplication"_s);
+        && inheritsFrom(metaClass, u"QCoreApplication"_s);
 
     QString tp_flags = u"Py_TPFLAGS_DEFAULT"_s;
     if (!metaClass->attributes().testFlag(AbstractMetaClass::FinalCppClass))
@@ -4757,25 +4433,31 @@ void CppGenerator::writeClassDefinition(TextStream &s,
     if (generateRichComparison(classContext))
         tp_richcompare = cpythonBaseName(metaClass) + u"_richcompare"_s;
 
+    const bool isSmartPointer = classContext.forSmartPointer();
     QString tp_getset;
-    if (shouldGenerateGetSetList(metaClass) && !classContext.forSmartPointer())
+    if (shouldGenerateGetSetList(metaClass) && !isSmartPointer)
         tp_getset = cpythonGettersSettersDefinitionName(metaClass);
 
     // search for special functions
     clearTpFuncs();
     for (const auto &func : metaClass->functions()) {
-        if (m_tpFuncs.contains(func->name()))
-            m_tpFuncs[func->name()] = cpythonFunctionName(func);
+        // Special non-operator functions identified by name
+        auto it = m_tpFuncs.find(func->name());
+        if (it != m_tpFuncs.end())
+            it.value() = cpythonFunctionName(func);
+        else if ( it = m_nbFuncs.find(func->name()); it !=  m_nbFuncs.end() )
+            it.value() = cpythonFunctionName(func);
     }
-    if (m_tpFuncs.value(reprFunction()).isEmpty()
-        && metaClass->hasToStringCapability()) {
-        m_tpFuncs[reprFunction()] = writeReprFunction(s,
-                classContext,
-                metaClass->toStringCapabilityIndirections());
+    if (m_tpFuncs.value(REPR_FUNCTION).isEmpty()
+        && (isSmartPointer || metaClass->hasToStringCapability())) {
+        const QString name = isSmartPointer
+          ? writeSmartPointerReprFunction(s, classContext)
+          : writeReprFunction(s, classContext, metaClass->toStringCapabilityIndirections());
+        m_tpFuncs[REPR_FUNCTION] = name;
     }
 
     // class or some ancestor has multiple inheritance
-    const AbstractMetaClass *miClass = getMultipleInheritingClass(metaClass);
+    const auto miClass = getMultipleInheritingClass(metaClass);
     if (miClass) {
         if (metaClass == miClass)
             writeMultipleInheritanceInitializerFunction(s, metaClass);
@@ -4789,8 +4471,8 @@ void CppGenerator::writeClassDefinition(TextStream &s,
     if (hasHashFunction(metaClass))
         tp_hash = u'&' + cpythonBaseName(metaClass) + u"_HashFunc"_s;
 
-    const auto callOp = metaClass->findFunction(u"operator()");
-    if (!callOp.isNull() && !callOp->isModifiedRemoved())
+    const auto callOp = metaClass->findFunction("operator()");
+    if (callOp && !callOp->isModifiedRemoved())
         tp_call = u'&' + cpythonFunctionName(callOp);
 
     const QString typePtr = u"_"_s + className
@@ -4801,7 +4483,7 @@ void CppGenerator::writeClassDefinition(TextStream &s,
         << "}\n\nstatic PyType_Slot " << className << "_slots[] = {\n" << indent
         << "{Py_tp_base,        nullptr}, // inserted by introduceWrapperType\n"
         << pyTypeSlotEntry("Py_tp_dealloc", tp_dealloc)
-        << pyTypeSlotEntry("Py_tp_repr", m_tpFuncs.value(reprFunction()))
+      << pyTypeSlotEntry("Py_tp_repr", m_tpFuncs.value(REPR_FUNCTION))
         << pyTypeSlotEntry("Py_tp_hash", tp_hash)
         << pyTypeSlotEntry("Py_tp_call", tp_call)
         << pyTypeSlotEntry("Py_tp_str", m_tpFuncs.value(u"__str__"_s))
@@ -4825,7 +4507,6 @@ void CppGenerator::writeClassDefinition(TextStream &s,
         writeTypeAsMappingDefinition(s, metaClass);
     }
     if (supportsNumberProtocol(metaClass)) {
-        // This one must come last. See the function itself.
         s << "// type supports number protocol\n";
         writeTypeAsNumberDefinition(s, metaClass);
     }
@@ -4840,12 +4521,12 @@ void CppGenerator::writeClassDefinition(TextStream &s,
 }
 
 void CppGenerator::writeMappingMethods(TextStream &s,
-                                       const AbstractMetaClass *metaClass,
+                                       const AbstractMetaClassCPtr &metaClass,
                                        const GeneratorContext &context) const
 {
     for (const auto & m : mappingProtocols()) {
         const auto func = metaClass->findFunction(m.name);
-        if (func.isNull())
+        if (!func)
             continue;
         QString funcName = cpythonFunctionName(func);
         CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode);
@@ -4862,14 +4543,14 @@ void CppGenerator::writeMappingMethods(TextStream &s,
 }
 
 void CppGenerator::writeSequenceMethods(TextStream &s,
-                                        const AbstractMetaClass *metaClass,
+                                        const AbstractMetaClassCPtr &metaClass,
                                         const GeneratorContext &context) const
 {
     bool injectedCode = false;
 
     for (const auto &seq : sequenceProtocols()) {
         const auto func = metaClass->findFunction(seq.name);
-        if (func.isNull())
+        if (!func)
             continue;
         injectedCode = true;
         QString funcName = cpythonFunctionName(func);
@@ -4893,25 +4574,25 @@ void CppGenerator::writeSequenceMethods(TextStream &s,
 static const QHash<QString, QString> &sqFuncs()
 {
     static const QHash<QString, QString> result = {
-        {u"__concat__"_s, u"sq_concat"_s},
-        {u"__contains__"_s, u"sq_contains"_s},
-        {u"__getitem__"_s, u"sq_item"_s},
-        {u"__getslice__"_s, u"sq_slice"_s},
-        {u"__len__"_s, u"sq_length"_s},
-        {u"__setitem__"_s, u"sq_ass_item"_s},
-        {u"__setslice__"_s, u"sq_ass_slice"_s}
+        {u"__concat__"_s, u"Py_sq_concat"_s},
+        {u"__contains__"_s, u"Py_sq_contains"_s},
+        {u"__getitem__"_s, u"Py_sq_item"_s},
+        {u"__getslice__"_s, u"Py_sq_slice"_s},
+        {u"__len__"_s, u"Py_sq_length"_s},
+        {u"__setitem__"_s, u"Py_sq_ass_item"_s},
+        {u"__setslice__"_s, u"Py_sq_ass_slice"_s}
     };
     return result;
 }
 
 void CppGenerator::writeTypeAsSequenceDefinition(TextStream &s,
-                                                 const AbstractMetaClass *metaClass)
+                                                 const AbstractMetaClassCPtr &metaClass)
 {
     bool hasFunctions = false;
     QMap<QString, QString> funcs;
     for (const auto &seq : sequenceProtocols()) {
         const auto func = metaClass->findFunction(seq.name);
-        if (!func.isNull()) {
+        if (func) {
             funcs.insert(seq.name, u'&' + cpythonFunctionName(func));
             hasFunctions = true;
         }
@@ -4929,38 +4610,34 @@ void CppGenerator::writeTypeAsSequenceDefinition(TextStream &s,
     for (auto it = sqFuncs().cbegin(), end = sqFuncs().cend(); it != end; ++it) {
         const QString &sqName = it.key();
         auto fit = funcs.constFind(sqName);
-        if (fit != funcs.constEnd()) {
-            s <<  "{Py_" << it.value() << ", reinterpret_cast<void *>("
-               << fit.value() << ")},\n";
-        }
+        if (fit != funcs.constEnd())
+            s << pyTypeSlotEntry(it.value(), fit.value());
     }
 }
 
 void CppGenerator::writeTypeAsMappingDefinition(TextStream &s,
-                                                const AbstractMetaClass *metaClass)
+                                                const AbstractMetaClassCPtr &metaClass)
 {
     // Sequence protocol structure members names
     static const QHash<QString, QString> mpFuncs{
-        {u"__mlen__"_s, u"mp_length"_s},
-        {u"__mgetitem__"_s, u"mp_subscript"_s},
-        {u"__msetitem__"_s, u"mp_ass_subscript"_s},
+        {u"__mlen__"_s, u"Py_mp_length"_s},
+        {u"__mgetitem__"_s, u"Py_mp_subscript"_s},
+        {u"__msetitem__"_s, u"Py_mp_ass_subscript"_s},
     };
     QMap<QString, QString> funcs;
     for (const auto &m : mappingProtocols()) {
         const auto func = metaClass->findFunction(m.name);
-        if (!func.isNull()) {
+        if (func) {
             const QString entry = u"reinterpret_cast<void *>(&"_s
                                   + cpythonFunctionName(func) + u')';
             funcs.insert(m.name, entry);
-        } else {
-            funcs.insert(m.name, NULL_PTR);
         }
     }
 
     for (auto it = mpFuncs.cbegin(), end = mpFuncs.cend(); it != end; ++it) {
         const auto fit = funcs.constFind(it.key());
         if (fit != funcs.constEnd())
-            s <<  "{Py_" << it.value() << ", " << fit.value() <<  "},\n";
+            s << pyTypeSlotEntry(it.value(), fit.value());
     }
 }
 
@@ -4968,105 +4645,102 @@ void CppGenerator::writeTypeAsMappingDefinition(TextStream &s,
 static const QHash<QString, QString> &nbFuncs()
 {
     static const QHash<QString, QString> result = {
-        {u"__add__"_s, u"nb_add"_s},
-        {u"__sub__"_s, u"nb_subtract"_s},
-        {u"__mul__"_s, u"nb_multiply"_s},
-        {u"__div__"_s, u"nb_divide"_s},
-        {u"__mod__"_s, u"nb_remainder"_s},
-        {u"__neg__"_s, u"nb_negative"_s},
-        {u"__pos__"_s, u"nb_positive"_s},
-        {u"__invert__"_s, u"nb_invert"_s},
-        {u"__lshift__"_s, u"nb_lshift"_s},
-        {u"__rshift__"_s, u"nb_rshift"_s},
-        {u"__and__"_s, u"nb_and"_s},
-        {u"__xor__"_s, u"nb_xor"_s},
-        {u"__or__"_s, u"nb_or"_s},
-        {u"__iadd__"_s, u"nb_inplace_add"_s},
-        {u"__isub__"_s, u"nb_inplace_subtract"_s},
-        {u"__imul__"_s, u"nb_inplace_multiply"_s},
-        {u"__idiv__"_s, u"nb_inplace_divide"_s},
-        {u"__imod__"_s, u"nb_inplace_remainder"_s},
-        {u"__ilshift__"_s, u"nb_inplace_lshift"_s},
-        {u"__irshift__"_s, u"nb_inplace_rshift"_s},
-        {u"__iand__"_s, u"nb_inplace_and"_s},
-        {u"__ixor__"_s, u"nb_inplace_xor"_s},
-        {u"__ior__"_s, u"nb_inplace_or"_s},
-        {boolT(), u"nb_nonzero"_s}
+        {u"__abs__"_s, u"Py_nb_absolute"_s},
+        {u"__add__"_s, u"Py_nb_add"_s},
+        {u"__sub__"_s, u"Py_nb_subtract"_s},
+        {u"__mul__"_s, u"Py_nb_multiply"_s},
+        {u"__div__"_s, u"Py_nb_true_divide"_s},
+        {u"__mod__"_s, u"Py_nb_remainder"_s},
+        {u"__neg__"_s, u"Py_nb_negative"_s},
+        {u"__pos__"_s, u"Py_nb_positive"_s},
+        {u"__pow__"_s, u"Py_nb_power"_s},
+        {u"__invert__"_s, u"Py_nb_invert"_s},
+        {u"__lshift__"_s, u"Py_nb_lshift"_s},
+        {u"__rshift__"_s, u"Py_nb_rshift"_s},
+        {u"__and__"_s, u"Py_nb_and"_s},
+        {u"__xor__"_s, u"Py_nb_xor"_s},
+        {u"__or__"_s, u"Py_nb_or"_s},
+        {u"__iadd__"_s, u"Py_nb_inplace_add"_s},
+        {u"__isub__"_s, u"Py_nb_inplace_subtract"_s},
+        {u"__imul__"_s, u"Py_nb_inplace_multiply"_s},
+        {u"__imod__"_s, u"Py_nb_inplace_remainder"_s},
+        {u"__ilshift__"_s, u"Py_nb_inplace_lshift"_s},
+        {u"__irshift__"_s, u"Py_nb_inplace_rshift"_s},
+        {u"__iand__"_s, u"Py_nb_inplace_and"_s},
+        {u"__ixor__"_s, u"Py_nb_inplace_xor"_s},
+        {u"__ior__"_s, u"Py_nb_inplace_or"_s},
+        {u"__bool__"_s, u"Py_nb_bool"_s},
+        {u"__int__"_s, u"Py_nb_int"_s},
+        {u"__float__"_s, u"Py_nb_float"_s}
     };
     return result;
 }
 
-void CppGenerator::writeTypeAsNumberDefinition(TextStream &s, const AbstractMetaClass *metaClass) const
+void CppGenerator::writeTypeAsNumberDefinition(TextStream &s, const AbstractMetaClassCPtr &metaClass) const
 {
     QMap<QString, QString> nb;
 
-    const QList<AbstractMetaFunctionCList> opOverloads =
-            filterGroupedOperatorFunctions(metaClass,
-                                           OperatorQueryOption::ArithmeticOp
-                                           | OperatorQueryOption::IncDecrementOp
-                                           | OperatorQueryOption::LogicalOp
-                                           | OperatorQueryOption::BitwiseOp);
-
-    for (const AbstractMetaFunctionCList &opOverload : opOverloads) {
+    const QList<AbstractMetaFunctionCList> opOverloads = numberProtocolOperators(metaClass);
+    for (const auto &opOverload : opOverloads) {
         const auto rfunc = opOverload.at(0);
         QString opName = ShibokenGenerator::pythonOperatorFunctionName(rfunc);
         nb[opName] = cpythonFunctionName(rfunc);
     }
 
+    for (auto it = m_nbFuncs.cbegin(), end = m_nbFuncs.cend(); it != end; ++it) {
+        if (!it.value().isEmpty())
+            nb.insert(it.key(), it.value());
+    }
+
     QString baseName = cpythonBaseName(metaClass);
 
     if (hasBoolCast(metaClass))
-        nb.insert(boolT(), baseName + u"___nb_bool"_s);
+        nb.insert(u"__bool__"_s, baseName + u"___nb_bool"_s);
 
     for (auto it = nbFuncs().cbegin(), end = nbFuncs().cend(); it != end; ++it) {
         const QString &nbName = it.key();
-        if (nbName == u"__div__" || nbName == u"__idiv__")
-            continue; // excludeFromPy3K
         const auto nbIt = nb.constFind(nbName);
-        if (nbIt != nb.constEnd()) {
-            const QString fixednbName = nbName == boolT()
-                ? u"nb_bool"_s : it.value();
-            s <<  "{Py_" << fixednbName << ", reinterpret_cast<void *>("
-               << nbIt.value() << ")},\n";
-        }
-    }
-
-    auto nbIt = nb.constFind(u"__div__"_s);
-    if (nbIt != nb.constEnd())
-        s << "{Py_nb_true_divide, reinterpret_cast<void *>(" << nbIt.value() << ")},\n";
-
-    nbIt = nb.constFind(u"__idiv__"_s);
-    if (nbIt != nb.constEnd()) {
-        s << "// This function is unused in Python 3. We reference it here.\n"
-            << "{0, reinterpret_cast<void *>(" << nbIt.value() << ")},\n"
-            << "// This list is ending at the first 0 entry.\n"
-            << "// Therefore, we need to put the unused functions at the very end.\n";
+        if (nbIt != nb.constEnd())
+            s << pyTypeSlotEntry(it.value(), nbIt.value());
     }
 }
 
-void CppGenerator::writeTpTraverseFunction(TextStream &s, const AbstractMetaClass *metaClass)
+void CppGenerator::writeTpTraverseFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass)
 {
     QString baseName = cpythonBaseName(metaClass);
     s << "static int " << baseName
         << "_traverse(PyObject *self, visitproc visit, void *arg)\n{\n" << indent
-        << "return SbkObject_TypeF()->tp_traverse(self, visit, arg);\n"
+        << "auto traverseProc = "
+        << pyTypeGetSlot("traverseproc", sbkObjectTypeF, "Py_tp_traverse") << ";\n"
+        << "return traverseProc(self, visit, arg);\n"
         << outdent << "}\n";
 }
 
-void CppGenerator::writeTpClearFunction(TextStream &s, const AbstractMetaClass *metaClass)
+void CppGenerator::writeTpClearFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass)
 {
     QString baseName = cpythonBaseName(metaClass);
     s << "static int " << baseName << "_clear(PyObject *self)\n{\n" << indent
-       << "return reinterpret_cast<PyTypeObject *>(SbkObject_TypeF())->tp_clear(self);\n"
+       << "auto clearProc = "
+       << pyTypeGetSlot("inquiry", sbkObjectTypeF, "Py_tp_clear") << ";\n"
+       << "return clearProc(self);\n"
        << outdent << "}\n";
 }
 
-void CppGenerator::writeCopyFunction(TextStream &s, const GeneratorContext &context) const
+QString CppGenerator::writeCopyFunction(TextStream &s,
+                                        TextStream &definitionStream,
+                                        TextStream &signatureStream,
+                                        const GeneratorContext &context)
 {
-    const AbstractMetaClass *metaClass = context.metaClass();
+    const auto metaClass = context.metaClass();
     const QString className = chopType(cpythonTypeName(metaClass));
-    s << "static PyObject *" << className << "___copy__(PyObject *self)\n"
-        << "{\n" << indent;
+    const QString funcName = className + u"__copy__"_s;
+
+    signatureStream << fullPythonClassName(metaClass) << ".__copy__()\n";
+    definitionStream << PyMethodDefEntry{u"__copy__"_s, funcName, {"METH_NOARGS"_ba}, {}}
+                     << ",\n";
+
+    s << "static PyObject *" << funcName << "(PyObject *self)\n"
+      << "{\n" << indent;
     writeCppSelfDefinition(s, context, ErrorReturn::Default, CppSelfDefinitionFlag::CppSelfAsReference);
     QString conversionCode;
     if (!context.forSmartPointer())
@@ -5079,16 +4753,18 @@ void CppGenerator::writeCopyFunction(TextStream &s, const GeneratorContext &cont
     writeFunctionReturnErrorCheckSection(s, ErrorReturn::Default);
     s << "return " << PYTHON_RETURN_VAR << ";\n" << outdent
         << "}\n\n";
+
+    return funcName;
 }
 
 static inline void writeGetterFunctionStart(TextStream &s, const QString &funcName)
 {
-    s << "static PyObject *" << funcName << "(PyObject *self, void *)\n"
+    s << "static PyObject *" << funcName << "(PyObject *self, void * /* closure */)\n"
        << "{\n" << indent;
 }
 
 QString CppGenerator::cppFieldAccess(const AbstractMetaField &metaField,
-                                     const GeneratorContext &context) const
+                                     const GeneratorContext &context)
 {
     QString result;
     QTextStream str(&result);
@@ -5102,7 +4778,7 @@ QString CppGenerator::cppFieldAccess(const AbstractMetaField &metaField,
 
 void CppGenerator::writeGetterFunction(TextStream &s,
                                        const AbstractMetaField &metaField,
-                                       const GeneratorContext &context) const
+                                       const GeneratorContext &context)
 {
     writeGetterFunctionStart(s, cpythonGetterFunctionName(metaField));
 
@@ -5144,7 +4820,7 @@ void CppGenerator::writeGetterFunction(TextStream &s,
             << "pyOut = reinterpret_cast<PyObject *>(Shiboken::Object::findColocatedChild("
             << "reinterpret_cast<SbkObject *>(self), "
             << cpythonTypeNameExt(fieldType) << "));\n"
-            << "if (pyOut) {\n" << indent
+            << "if (pyOut != nullptr) {\n" << indent
             << "Py_IncRef(pyOut);\n"
             << "return pyOut;\n"
             << outdent << "}\n";
@@ -5156,7 +4832,14 @@ void CppGenerator::writeGetterFunction(TextStream &s,
             << "Py_IncRef(pyOut);" << "\n"
             << "return pyOut;" << "\n"
             << outdent << "}\n";
-        // Create and register new wrapper
+        // Create and register new wrapper. We force a pointer conversion also
+        // for wrapped value types so that they refer to the struct member,
+        // avoiding any trouble copying them. Add a parent relationship to
+        // properly notify if the struct is deleted (see protected_test.py,
+        // testProtectedValueTypeProperty()). Note that this has currently
+        // unsolved issues when using temporary Python lists of structs
+        // which can cause elements to be reported deleted in expressions like
+        // "foo.list_of_structs[2].field".
         s << "pyOut = "
             << "Shiboken::Object::newObject(" << cpythonTypeNameExt(fieldType)
             << ", " << cppField << ", false, true);\n"
@@ -5169,27 +4852,29 @@ void CppGenerator::writeGetterFunction(TextStream &s,
 }
 
 // Write a getter for QPropertySpec
-void CppGenerator::writeGetterFunction(TextStream &s, const QPropertySpec &property,
-                                       const GeneratorContext &context) const
+void CppGenerator::writeGetterFunction(TextStream &s,
+                                       const QPropertySpec &property,
+                                       const GeneratorContext &context)
 {
     writeGetterFunctionStart(s, cpythonGetterFunctionName(property, context.metaClass()));
     writeCppSelfDefinition(s, context);
-    const QString value = QStringLiteral("value");
+    const QString value = "value"_L1;
     s << "auto " << value << " = " << CPP_SELF_VAR << "->" << property.read() << "();\n"
-        << "auto pyResult = ";
+        << "auto *pyResult = ";
     writeToPythonConversion(s, property.type(), context.metaClass(), value);
-    s << ";\nif (PyErr_Occurred() || !pyResult) {\n" << indent
-        << "Py_XDECREF(pyResult);\nreturn {};\n" << outdent
+    s << ";\nif (" << shibokenErrorsOccurred << " || pyResult == nullptr) {\n"
+        << indent << "Py_XDECREF(pyResult);\nreturn {};\n" << outdent
         << "}\nreturn pyResult;\n" << outdent << "}\n\n";
 }
 
 // Write setter function preamble (type checks on "pyIn")
-void CppGenerator::writeSetterFunctionPreamble(TextStream &s, const QString &name,
+void CppGenerator::writeSetterFunctionPreamble(TextStream &s,
+                                               const QString &name,
                                                const QString &funcName,
                                                const AbstractMetaType &type,
-                                               const GeneratorContext &context) const
+                                               const GeneratorContext &context)
 {
-    s << "static int " << funcName << "(PyObject *self, PyObject *pyIn, void *)\n"
+    s << "static int " << funcName << "(PyObject *self, PyObject *pyIn, void * /* closure */)\n"
         << "{\n" << indent;
 
     writeCppSelfDefinition(s, context, ErrorReturn::Zero);
@@ -5211,7 +4896,7 @@ void CppGenerator::writeSetterFunctionPreamble(TextStream &s, const QString &nam
 
 void CppGenerator::writeSetterFunction(TextStream &s,
                                        const AbstractMetaField &metaField,
-                                       const GeneratorContext &context) const
+                                       const GeneratorContext &context)
 {
     const AbstractMetaType &fieldType = metaField.type();
     writeSetterFunctionPreamble(s, metaField.name(), cpythonSetterFunctionName(metaField),
@@ -5243,16 +4928,18 @@ void CppGenerator::writeSetterFunction(TextStream &s,
 }
 
 // Write a setter for QPropertySpec
-void CppGenerator::writeSetterFunction(TextStream &s, const QPropertySpec &property,
-                                       const GeneratorContext &context) const
+void CppGenerator::writeSetterFunction(TextStream &s,
+                                       const QPropertySpec &property,
+                                       const GeneratorContext &context)
 {
-    writeSetterFunctionPreamble(s, property.name(),
+    writeSetterFunctionPreamble(s,
+                                property.name(),
                                 cpythonSetterFunctionName(property, context.metaClass()),
                                 property.type(), context);
 
     s << "auto cppOut = " << CPP_SELF_VAR << "->" << property.read() << "();\n"
         << PYTHON_TO_CPP_VAR << "(pyIn, &cppOut);\n"
-        << "if (PyErr_Occurred())\n" << indent
+        << "if (" << shibokenErrorsOccurred << ")\n" << indent
         << "return -1;\n" << outdent
         << CPP_SELF_VAR << "->" << property.write() << "(cppOut);\n"
         << "return 0;\n" << outdent << "}\n\n";
@@ -5260,7 +4947,7 @@ void CppGenerator::writeSetterFunction(TextStream &s, const QPropertySpec &prope
 
 void CppGenerator::writeRichCompareFunctionHeader(TextStream &s,
                                                   const QString &baseName,
-                                                  const GeneratorContext &context) const
+                                                  const GeneratorContext &context)
 {
     s << "static PyObject * ";
     s << baseName << "_richcompare(PyObject *self, PyObject *" << PYTHON_ARG
@@ -5272,13 +4959,10 @@ void CppGenerator::writeRichCompareFunctionHeader(TextStream &s,
         << sbkUnusedVariableCast(PYTHON_TO_CPP_VAR) << '\n';
 }
 
-static const char richCompareComment[] =
-    "// PYSIDE-74: By default, we redirect to object's tp_richcompare (which is `==`, `!=`).\n";
-
 void CppGenerator::writeRichCompareFunction(TextStream &s,
                                             const GeneratorContext &context) const
 {
-    const AbstractMetaClass *metaClass = context.metaClass();
+    const auto metaClass = context.metaClass();
     QString baseName = cpythonBaseName(metaClass);
     writeRichCompareFunctionHeader(s, baseName, context);
 
@@ -5363,7 +5047,8 @@ void CppGenerator::writeRichCompareFunction(TextStream &s,
                 << (op == AbstractMetaFunction::OperatorEqual ? "Py_False" : "Py_True") << ";\n"
                 << "Py_INCREF(" << PYTHON_RETURN_VAR << ");\n" << outdent;
         } else {
-            s << indent << "goto " << baseName << "_RichComparison_TypeError;\n" << outdent;
+            s << indent << "return Shiboken::returnFromRichCompare("
+                << PYTHON_RETURN_VAR << ");\n" << outdent;
         }
         s << "}\n\n";
 
@@ -5372,130 +5057,9 @@ void CppGenerator::writeRichCompareFunction(TextStream &s,
     s << "default:\n" << indent
         << richCompareComment
         << "return FallbackRichCompare(self, " << PYTHON_ARG << ", op);\n"
-        << "goto " << baseName << "_RichComparison_TypeError;\n" << outdent
-        << outdent << "}\n\n";
-
-    writeRichCompareFunctionFooter(s, baseName);
-}
-
-void CppGenerator::writeRichCompareFunctionFooter(TextStream &s,
-                                                  const QString &baseName)
-{
-    s << "if (" << PYTHON_RETURN_VAR << " && !PyErr_Occurred())\n" << indent
-        << "return " << PYTHON_RETURN_VAR << ";\n" << outdent
-        << baseName << "_RichComparison_TypeError:\n"
-        << "Shiboken::Errors::setOperatorNotImplemented();\n"
-        << ErrorReturn::Default << '\n' << outdent << "}\n\n";
-}
-
-using ComparisonOperatorList = QList<AbstractMetaFunction::ComparisonOperatorType>;
-
-// Return the available comparison operators for smart pointers
-static ComparisonOperatorList smartPointeeComparisons(const GeneratorContext &context)
-{
-    Q_ASSERT(context.forSmartPointer());
-    auto te = context.preciseType().instantiations().constFirst().typeEntry();
-    if (isExtendedCppPrimitive(te)) { // Primitive pointee types have all
-        return {AbstractMetaFunction::OperatorEqual,
-                AbstractMetaFunction::OperatorNotEqual,
-                AbstractMetaFunction::OperatorLess,
-                AbstractMetaFunction::OperatorLessEqual,
-                AbstractMetaFunction::OperatorGreater,
-                AbstractMetaFunction::OperatorGreaterEqual};
-    }
-
-    auto *pointeeClass = context.pointeeClass();
-    if (!pointeeClass)
-        return {};
-
-    ComparisonOperatorList result;
-    const auto &comparisons =
-        pointeeClass->operatorOverloads(OperatorQueryOption::SymmetricalComparisonOp);
-    for (const auto &f : comparisons) {
-        const auto ct = f->comparisonOperatorType().value();
-        if (!result.contains(ct))
-            result.append(ct);
-    }
-    return result;
-}
-
-void CppGenerator::writeSmartPointerRichCompareFunction(TextStream &s,
-                                                        const GeneratorContext &context) const
-{
-    static const char selfPointeeVar[] = "cppSelfPointee";
-    static const char cppArg0PointeeVar[] = "cppArg0Pointee";
-
-    const AbstractMetaClass *metaClass = context.metaClass();
-    QString baseName = cpythonBaseName(metaClass);
-    writeRichCompareFunctionHeader(s, baseName, context);
-
-    s << "if (";
-    writeTypeCheck(s, context.preciseType(), PYTHON_ARG);
-    s << ") {\n" << indent;
-    writeArgumentConversion(s, context.preciseType(), CPP_ARG0,
-                            PYTHON_ARG, ErrorReturn::Default, metaClass);
-
-    const auto te = context.preciseType().typeEntry();
-    Q_ASSERT(te->isSmartPointer());
-    const auto ste = qSharedPointerCast<const SmartPointerTypeEntry>(te);
-
-    s << "const auto *" << selfPointeeVar << " = " << CPP_SELF_VAR
-        << '.' << ste->getter() << "();\n";
-    s << "const auto *" << cppArg0PointeeVar << " = " << CPP_ARG0
-        << '.' << ste->getter() << "();\n";
-
-    // If we have an object without any comparisons, only generate a simple
-    // equality check by pointee address
-    auto availableOps = smartPointeeComparisons(context);
-    const bool comparePointeeAddressOnly = availableOps.isEmpty();
-    if (comparePointeeAddressOnly) {
-        availableOps << AbstractMetaFunction::OperatorEqual
-            << AbstractMetaFunction::OperatorNotEqual;
-    } else {
-        // For value types with operators, we complain about nullptr
-        s << "if (" << selfPointeeVar << " == nullptr || " << cppArg0PointeeVar
-            << " == nullptr) {\n" << indent
-            << "PyErr_SetString(PyExc_NotImplementedError, \"nullptr passed to comparison.\");\n"
-            << ErrorReturn::Default << '\n' << outdent << "}\n";
-    }
-
-    s << "bool " << CPP_RETURN_VAR << "= false;\n"
-        << "switch (op) {\n";
-    for (auto op : availableOps) {
-        s << "case " << AbstractMetaFunction::pythonRichCompareOpCode(op) << ":\n"
-          << indent << CPP_RETURN_VAR << " = ";
-        if (comparePointeeAddressOnly) {
-            s << selfPointeeVar << ' ' << AbstractMetaFunction::cppComparisonOperator(op)
-              << ' ' << cppArg0PointeeVar << ";\n";
-        } else {
-            // Shortcut for equality: Check pointee address
-            if (op == AbstractMetaFunction::OperatorEqual
-                || op == AbstractMetaFunction::OperatorLessEqual
-                || op == AbstractMetaFunction::OperatorGreaterEqual) {
-                s << selfPointeeVar << " == " << cppArg0PointeeVar << " || ";
-            }
-            // Generate object's comparison
-            s << "*" << selfPointeeVar << ' '
-              << AbstractMetaFunction::cppComparisonOperator(op) << " *"
-              << cppArg0PointeeVar << ";\n";
-        }
-        s << "break;\n" << outdent;
-
-    }
-    if (availableOps.size() < 6) {
-        s << "default:\n" << indent
-            << richCompareComment
-            << "return FallbackRichCompare(self, " << PYTHON_ARG << ", op);\n" << outdent;
-    }
-    s << "}\n" << PYTHON_RETURN_VAR << " = " << CPP_RETURN_VAR
-        << " ? Py_True : Py_False;\n"
-        << "Py_INCREF(" << PYTHON_RETURN_VAR << ");\n";
-
-    s << outdent << "} else {\n" << indent
-      << "goto " << baseName << "_RichComparison_TypeError;\n"
-      << outdent << "}\n";
-
-    writeRichCompareFunctionFooter(s, baseName);
+        << outdent << outdent << "}\n\n"
+    << "return Shiboken::returnFromRichCompare(" << PYTHON_RETURN_VAR << ");\n" << outdent
+    << "}\n\n";
 }
 
 // Return a flag combination for PyMethodDef
@@ -5516,9 +5080,9 @@ QByteArrayList CppGenerator::methodDefinitionParameters(const OverloadData &over
     }
     // METH_STATIC causes a crash when used for global functions (also from
     // invisible namespaces).
-    auto *ownerClass = overloadData.referenceFunction()->ownerClass();
+    const auto ownerClass = overloadData.referenceFunction()->ownerClass();
     if (ownerClass
-        && !invisibleTopNamespaces().contains(const_cast<AbstractMetaClass *>(ownerClass))) {
+        && !invisibleTopNamespaces().contains(std::const_pointer_cast<AbstractMetaClass>(ownerClass))) {
         if (overloadData.hasStaticFunction())
             result.append(QByteArrayLiteral("METH_STATIC"));
         if (overloadData.hasClassMethod())
@@ -5542,6 +5106,17 @@ QList<PyMethodDefEntry>
     return result;
 }
 
+QString CppGenerator::pythonSignature(const AbstractMetaType &type) const
+{
+    if (type.isSmartPointer() && !type.instantiations().isEmpty()) {
+        const auto ste = std::static_pointer_cast<const SmartPointerTypeEntry>(type.typeEntry());
+        const auto instantiationTe = type.instantiations().constFirst().typeEntry();
+        if (auto opt = api().findSmartPointerInstantiation(ste, instantiationTe))
+            return opt->specialized->typeEntry()->qualifiedTargetLangName();
+    }
+    return type.pythonSignature();
+}
+
 // Format the type signature of a function parameter
 QString CppGenerator::signatureParameter(const AbstractMetaArgument &arg) const
 {
@@ -5553,17 +5128,22 @@ QString CppGenerator::signatureParameter(const AbstractMetaArgument &arg) const
         metaType = *viewOn;
     s << arg.name() << ':';
 
-    QStringList signatures(metaType.pythonSignature());
+    QStringList signatures(pythonSignature(metaType));
 
     // Implicit conversions (C++): Check for converting constructors
     // "QColor(Qt::GlobalColor)" or conversion operators
     const AbstractMetaFunctionCList conversions =
         api().implicitConversions(metaType);
     for (const auto &f : conversions) {
-        if (f->isConstructor() && !f->arguments().isEmpty())
-            signatures << f->arguments().constFirst().type().pythonSignature();
-        else if (f->isConversionOperator())
+        if (f->isConstructor() && !f->arguments().isEmpty()) {
+            // PYSIDE-2712: modified types from converting constructors are not always correct
+            // candidates if they are modified by the type system reference
+            if (!f->arguments().constFirst().isTypeModified()) {
+                signatures << pythonSignature(f->arguments().constFirst().type());
+            }
+        } else if (f->isConversionOperator()) {
             signatures << f->ownerClass()->fullName();
+        }
     }
 
     const qsizetype size = signatures.size();
@@ -5577,12 +5157,6 @@ QString CppGenerator::signatureParameter(const AbstractMetaArgument &arg) const
     if (size > 1)
         s << ']';
 
-    if (!arg.defaultValueExpression().isEmpty()) {
-        s << '=';
-        QString e = arg.defaultValueExpression();
-        e.replace(u"::"_s, u"."_s);
-        s << e;
-    }
     return result;
 }
 
@@ -5599,18 +5173,22 @@ void CppGenerator::writeSignatureInfo(TextStream &s, const OverloadData &overloa
         // PYSIDE-1328: `self`-ness cannot be computed in Python because there are mixed cases.
         // Toplevel functions like `PySide6.QtCore.QEnum` are always self-less.
         if (!(f->isStatic()) && f->ownerClass())
-            args << u"self"_s;
+            args << PYTHON_SELF_VAR;
         const auto &arguments = f->arguments();
         for (qsizetype i = 0, size = arguments.size(); i < size; ++i) {
             const auto n = i + 1;
+            const auto &arg = arguments.at(i);
             if (!f->argumentRemoved(n)) {
                 QString t = f->pyiTypeReplaced(n);
                 if (t.isEmpty()) {
-                    t = signatureParameter(arguments.at(i));
+                    t = signatureParameter(arg);
                 } else {
                     t.prepend(u':');
-                    t.prepend(arguments.at(i).name());
+                    t.prepend(arg.name());
                 }
+                QString defaultValue = arg.defaultValueExpression();
+                if (!defaultValue.isEmpty())
+                    t += u'=' + defaultValue.replace(u"::"_s, u"."_s);
                 args.append(t);
             }
         }
@@ -5622,7 +5200,7 @@ void CppGenerator::writeSignatureInfo(TextStream &s, const OverloadData &overloa
 
         QString returnType = f->pyiTypeReplaced(0); // pyi or modified type
         if (returnType.isEmpty() && !f->isVoid())
-            returnType = f->type().pythonSignature();
+            returnType = pythonSignature(f->type());
         if (!returnType.isEmpty())
             s << "->" << returnType;
 
@@ -5630,43 +5208,44 @@ void CppGenerator::writeSignatureInfo(TextStream &s, const OverloadData &overloa
     }
 }
 
-void CppGenerator::writeEnumsInitialization(TextStream &s, AbstractMetaEnumList &enums,
-                                            ErrorReturn errorReturn) const
+void CppGenerator::writeEnumsInitialization(TextStream &s, AbstractMetaEnumList &enums)
 {
     if (enums.isEmpty())
         return;
-    bool preambleWrittenE = false;
-    bool preambleWrittenF = false;
+    bool preambleWritten = false;
+    bool etypeUsed = false;
+
     for (const AbstractMetaEnum &cppEnum : std::as_const(enums)) {
         if (cppEnum.isPrivate())
             continue;
-        if (!preambleWrittenE) {
+        if (!preambleWritten) {
             s << "// Initialization of enums.\n"
+                << "Shiboken::AutoDecRef tpDict{};\n"
                 << "PyTypeObject *EType{};\n\n";
-            preambleWrittenE = true;
+            preambleWritten = true;
         }
-        if (!preambleWrittenF && cppEnum.typeEntry()->flags()) {
-            s << "// Initialization of enums, flags part.\n"
-                << "PyTypeObject *FType{};\n\n";
-            preambleWrittenF = true;
-        }
-        writeEnumInitialization(s, cppEnum, errorReturn);
+        ConfigurableScope configScope(s, cppEnum.typeEntry());
+        etypeUsed |= writeEnumInitialization(s, cppEnum);
     }
+    if (preambleWritten && !etypeUsed)
+        s << sbkUnusedVariableCast("EType");
 }
 
-static QString mangleName(QString name)
+static qsizetype maxLineLength(const QStringList &list)
 {
-    if (name == u"None" || name == u"False" || name == u"True")
-        name += u'_';
-    return name;
+    qsizetype result = 0;
+    for (const auto &s : list) {
+        if (auto len = s.size(); len > result)
+            result = len;
+    }
+    return result;
 }
 
-void CppGenerator::writeEnumInitialization(TextStream &s, const AbstractMetaEnum &cppEnum,
-                                           ErrorReturn errorReturn) const
+bool CppGenerator::writeEnumInitialization(TextStream &s, const AbstractMetaEnum &cppEnum)
 {
-    const AbstractMetaClass *enclosingClass = cppEnum.targetLangEnclosingClass();
-    bool hasUpperEnclosingClass = enclosingClass
-                                  && enclosingClass->targetLangEnclosingClass() != nullptr;
+    const auto enclosingClass = cppEnum.targetLangEnclosingClass();
+    const bool hasUpperEnclosingClass = enclosingClass
+                                        && enclosingClass->targetLangEnclosingClass();
     EnumTypeEntryCPtr enumTypeEntry = cppEnum.typeEntry();
     QString enclosingObjectVariable;
     if (enclosingClass)
@@ -5680,96 +5259,115 @@ void CppGenerator::writeEnumInitialization(TextStream &s, const AbstractMetaEnum
     s << (cppEnum.isAnonymous() ? "anonymous enum identified by enum value" : "enum");
     s << " '" << cppEnum.name() << "'.\n";
 
-    QString enumVarTypeObj = cpythonTypeNameExt(enumTypeEntry);
-    if (!cppEnum.isAnonymous()) {
-        int packageLevel = packageName().count(u'.') + 1;
-        FlagsTypeEntryPtr flags = enumTypeEntry->flags();
-        if (!flags.isNull()) {
-            // The following could probably be made nicer:
-            // We need 'flags->flagsName()' with the full module/class path.
-            QString fullPath = getClassTargetFullName(cppEnum);
-            fullPath.truncate(fullPath.lastIndexOf(u'.') + 1);
-            s << "FType = PySide::QFlags::create(\""
-                << packageLevel << ':' << fullPath << flags->flagsName() << "\", \n" << indent
-                << cpythonEnumName(cppEnum) << "_number_slots);\n" << outdent
-                << cpythonTypeNameExt(flags) << " = FType;\n";
+    const QString userType = cppEnum.typeEntry()->cppType();
+    const bool isSigned = cppEnum.isSigned() && !userType.contains(u"unsigned"_s);
+    const bool isAccessible = !avoidProtectedHack() || !cppEnum.isProtected();
+    const auto enumValues = cppEnum.nonRejectedValues();
+
+    const QString prefix = cppEnum.name();
+
+    const QString intType = userType.isEmpty() ? cppEnum.underlyingType() : userType;
+
+    // Create a list of values
+    const QString initializerValues = prefix + u"_InitializerValues"_s;
+    const QString initializerName = prefix + u"_Initializer"_s;
+
+    // Build maybe array of enum names.
+    if (cppEnum.enumKind() != AnonymousEnum) {
+        s << "const char *" << initializerName << "[] = {\n" << indent;
+        for (const auto &enumValue : enumValues) {
+            QString name = mangleName(enumValue.name());
+            s << '\"' << name << "\",\n";
         }
+        s << "nullptr};\n" << outdent;
+    }
 
-        s << "EType = Shiboken::Enum::"
-            << ((enclosingClass
-                || hasUpperEnclosingClass) ? "createScopedEnum" : "createGlobalEnum")
-            << '(' << enclosingObjectVariable << ',' << '\n' << indent
-            << '"' << cppEnum.name() << "\",\n"
-                << '"' << packageLevel << ':' << getClassTargetFullName(cppEnum) << "\",\n"
-                << '"' << cppEnum.qualifiedCppName() << '"';
-        if (flags)
-            s << ",\nFType";
-        s << ");\n" << outdent
-            << "if (!EType)\n"
-            << indent << errorReturn << outdent << '\n';
-    }
-
-    for (const AbstractMetaEnumValue &enumValue : cppEnum.values()) {
-        if (enumTypeEntry->isEnumValueRejected(enumValue.name()))
-            continue;
+    int targetHexLen = 0;
+    QString usedIntType = userType;
+    if (usedIntType.isEmpty()) {
+        const int usedBits = cppEnum.usedBits();
+        targetHexLen = usedBits / 4;
+        usedIntType = AbstractMetaEnum::intTypeForSize(usedBits, cppEnum.isSigned());
+    }
 
-        QString enumValueText;
-        if (!avoidProtectedHack() || !cppEnum.isProtected()) {
-            enumValueText = cppEnum.typeEntry()->cppType();
-            if (enumValueText.isEmpty())
-                enumValueText = u"Shiboken::Enum::EnumValueType"_s;
-            enumValueText += u'(';
-            if (cppEnum.enclosingClass())
-                enumValueText += cppEnum.enclosingClass()->qualifiedCppName() + u"::"_s;
-            // Fully qualify the value which is required for C++ 11 enum classes.
-            if (!cppEnum.isAnonymous())
-                enumValueText += cppEnum.name() + u"::"_s;
-            enumValueText += enumValue.name();
-            enumValueText += u')';
-        } else {
-            enumValueText += enumValue.value().toString();
+    if (usedIntType != intType)
+        s << "// \"" << usedIntType << "\" used instead of \"" << intType << "\"\n";
+
+    // Calculating formatting columns
+    QString enumValuePrefix;
+    if (isAccessible) {
+        if (cppEnum.enclosingClass())
+            enumValuePrefix += cppEnum.enclosingClass()->qualifiedCppName() + u"::"_s;
+        if (!cppEnum.isAnonymous())
+            enumValuePrefix += cppEnum.name() + u"::"_s;
+    }
+
+    // Build array of enum values
+    if (enumValues.isEmpty()) {
+        s << "const " << usedIntType << " *" << initializerValues << "{};\n";
+    } else {
+        QStringList values;
+        values.reserve(enumValues.size());
+        s << "constexpr " << usedIntType << ' ' << initializerValues << "[] = {\n" << indent;
+        for (qsizetype idx = 0, last = enumValues.size() - 1; idx <= last; ++idx) {
+            const auto &enumValue = enumValues.at(idx);
+            QString line = usedIntType + u'(' + (isAccessible
+                               ? enumValuePrefix + enumValue.name()
+                               : enumValue.value().toString()) + u')';
+            if (idx != last)
+                line += u',';
+            values.append(line);
         }
 
-        const QString mangledName = mangleName(enumValue.name());
-        switch (cppEnum.enumKind()) {
-        case AnonymousEnum:
+        const auto len = maxLineLength(values) + 1;
+        for (qsizetype idx = 0, size = enumValues.size(); idx < size; ++idx) {
+            const auto &enumValue = enumValues.at(idx).value();
+            const char *numberSpace = enumValue.isNegative() ? " " : "  ";
+            s << values.at(idx) << Pad(' ', len - values.at(idx).size())
+                << "//" << numberSpace << enumValue.toHex(targetHexLen)
+                << numberSpace << enumValue.toString() << '\n';
+        }
+        s << "};\n" << outdent;
+    }
+
+    // Build initialization of anonymous enums
+    if (cppEnum.enumKind() == AnonymousEnum) {
+        int idx = 0;
+        for (const auto &enumValue : enumValues) {
+            const QString mangledName = mangleName(enumValue.name());
+            const QString pyValue = initializerValues + u'[' + QString::number(idx++) + u']';
             if (enclosingClass || hasUpperEnclosingClass) {
-                s << "{\n" << indent
-                    << "PyObject *anonEnumItem = PyLong_FromLong(" << enumValueText << ");\n"
-                    << "if (PyDict_SetItemString(reinterpret_cast<PyTypeObject *>("
-                    << enclosingObjectVariable
-                    << ")->tp_dict, \"" << mangledName << "\", anonEnumItem) < 0)\n"
-                    << indent << errorReturn << outdent
-                    << "Py_DECREF(anonEnumItem);\n" << outdent
-                    << "}\n";
+                s << "tpDict.reset(PepType_GetDict(reinterpret_cast<PyTypeObject *>("
+                    << enclosingObjectVariable << ")));\n"
+                    << "PyDict_SetItemString(tpDict.object(), \"" << mangledName << "\",\n"
+                    << indent << (isSigned ? "PyLong_FromLongLong" : "PyLong_FromUnsignedLongLong")
+                    << "(" << pyValue << "));\n" << outdent;
             } else {
-                s << "if (PyModule_AddIntConstant(module, \"" << mangledName << "\", ";
-                s << enumValueText << ") < 0)\n" << indent << errorReturn << outdent;
+                s << "PyModule_AddObject(module, \"" << mangledName << "\",\n" << indent
+                    << (isSigned ? "PyLong_FromLongLong" : "PyLong_FromUnsignedLongLong") << "("
+                    << pyValue << "));\n" << outdent;
             }
-            break;
-        case CEnum:
-            s << "if (!Shiboken::Enum::";
-            s << ((enclosingClass || hasUpperEnclosingClass) ? "createScopedEnumItem"
-                                                             : "createGlobalEnumItem");
-            s << '(' << "EType" << ',' << '\n' << indent
-                << enclosingObjectVariable << ", \"" << mangledName << "\", "
-                << enumValueText << "))\n" << errorReturn << outdent;
-            break;
-        case EnumClass:
-            s << "if (!Shiboken::Enum::createScopedEnumItem("
-                << "EType" << ",\n" << indent
-                << "EType" << ", \"" << mangledName << "\", "
-                << enumValueText << "))\n" << errorReturn << outdent;
-            break;
         }
     }
-    s << "// PYSIDE-1735: Resolving the whole enum class at the end for API compatibility.\n"
-        << "EType = morphLastEnumToPython();\n"
-        << enumVarTypeObj << " = EType;\n";
+
+    bool etypeUsed = false;
+
+    QString enumVarTypeObj = cpythonTypeNameExtSet(enumTypeEntry);
+    if (!cppEnum.isAnonymous()) {
+        int packageLevel = packageName().count(u'.') + 1;
+        s << "EType = Shiboken::Enum::"
+            << "createPythonEnum"
+            << '(' << enclosingObjectVariable << ",\n" << indent
+            << '"' << packageLevel << ':' << getClassTargetFullName(cppEnum) << "\",\n"
+            << initializerName << ", " << initializerValues << ");\n" << outdent
+            << enumVarTypeObj << " = EType;\n";
+        etypeUsed = true;
+    }
+
     if (cppEnum.typeEntry()->flags()) {
         s << "// PYSIDE-1735: Mapping the flags class to the same enum class.\n"
-            << cpythonTypeNameExt(cppEnum.typeEntry()->flags()) << " =\n"
-            << indent << "mapFlagsToSameEnum(FType, EType);\n" << outdent;
+            << cpythonTypeNameExtSet(cppEnum.typeEntry()->flags()) << " =\n"
+            << indent << "EType;\n" << outdent;
     }
     writeEnumConverterInitialization(s, cppEnum);
 
@@ -5777,9 +5375,11 @@ void CppGenerator::writeEnumInitialization(TextStream &s, const AbstractMetaEnum
     if (cppEnum.typeEntry()->flags())
         s << "/flags";
     s << ".\n\n";
+
+    return etypeUsed;
 }
 
-void CppGenerator::writeSignalInitialization(TextStream &s, const AbstractMetaClass *metaClass)
+void CppGenerator::writeSignalInitialization(TextStream &s, const AbstractMetaClassCPtr &metaClass)
 {
     // Try to check something and print some warnings
     const auto &signalFuncs = metaClass->cppSignalFunctions();
@@ -5801,136 +5401,11 @@ void CppGenerator::writeSignalInitialization(TextStream &s, const AbstractMetaCl
         }
     }
 
-    s << "PySide::Signal::registerSignals(pyType, &::"
+    s << "PySide::Signal::registerSignals(pyType, &" << m_gsp
        << metaClass->qualifiedCppName() << "::staticMetaObject);\n";
 }
 
-void CppGenerator::writeFlagsToLong(TextStream &s, const AbstractMetaEnum &cppEnum)
-{
-    FlagsTypeEntryPtr flagsEntry = cppEnum.typeEntry()->flags();
-    if (!flagsEntry)
-        return;
-    s << "static PyObject *" << cpythonEnumName(cppEnum) << "_long(PyObject *self)\n"
-        << "{\n" << indent
-        << "int val;\n";
-    AbstractMetaType flagsType = AbstractMetaType::fromTypeEntry(flagsEntry);
-    s << cpythonToCppConversionFunction(flagsType) << "self, &val);\n"
-        << "return Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &val);\n"
-        << outdent << "}\n";
-}
-
-void CppGenerator::writeFlagsNonZero(TextStream &s, const AbstractMetaEnum &cppEnum)
-{
-    FlagsTypeEntryPtr flagsEntry = cppEnum.typeEntry()->flags();
-    if (flagsEntry.isNull())
-        return;
-    s << "static int " << cpythonEnumName(cppEnum) << "__nonzero(PyObject *self)\n";
-    s << "{\n" << indent << "int val;\n";
-    AbstractMetaType flagsType = AbstractMetaType::fromTypeEntry(flagsEntry);
-    s << cpythonToCppConversionFunction(flagsType) << "self, &val);\n"
-        << "return val != 0;\n"
-        << outdent << "}\n";
-}
-
-void CppGenerator::writeFlagsMethods(TextStream &s, const AbstractMetaEnum &cppEnum)
-{
-    writeFlagsBinaryOperator(s, cppEnum, u"and"_s, u"&"_s);
-    writeFlagsBinaryOperator(s, cppEnum, u"or"_s, u"|"_s);
-    writeFlagsBinaryOperator(s, cppEnum, u"xor"_s, u"^"_s);
-
-    writeFlagsUnaryOperator(s, cppEnum, u"invert"_s, u"~"_s);
-    writeFlagsToLong(s, cppEnum);
-    writeFlagsNonZero(s, cppEnum);
-
-    s << '\n';
-}
-
-void CppGenerator::writeFlagsNumberMethodsDefinition(TextStream &s, const AbstractMetaEnum &cppEnum)
-{
-    QString cpythonName = cpythonEnumName(cppEnum);
-
-    s << "static PyType_Slot " << cpythonName << "_number_slots[] = {\n" << indent
-        << "{Py_nb_bool,    reinterpret_cast<void *>(" << cpythonName << "__nonzero)},\n"
-        << "{Py_nb_invert,  reinterpret_cast<void *>(" << cpythonName << "___invert__)},\n"
-        << "{Py_nb_and,     reinterpret_cast<void *>(" << cpythonName  << "___and__)},\n"
-        << "{Py_nb_xor,     reinterpret_cast<void *>(" << cpythonName  << "___xor__)},\n"
-        << "{Py_nb_or,      reinterpret_cast<void *>(" << cpythonName  << "___or__)},\n"
-        << "{Py_nb_int,     reinterpret_cast<void *>(" << cpythonName << "_long)},\n"
-        << "{Py_nb_index,   reinterpret_cast<void *>(" << cpythonName << "_long)},\n"
-        << "{0, " << NULL_PTR << "} // sentinel\n" << outdent
-        << "};\n\n";
-}
-
-void CppGenerator::writeFlagsNumberMethodsDefinitions(TextStream &s,
-                                                      const AbstractMetaEnumList &enums)
-{
-    for (const AbstractMetaEnum &e : enums) {
-        if (!e.isAnonymous() && !e.isPrivate() && e.typeEntry()->flags()) {
-            writeFlagsMethods(s, e);
-            writeFlagsNumberMethodsDefinition(s, e);
-            s << '\n';
-        }
-    }
-}
-
-void CppGenerator::writeFlagsBinaryOperator(TextStream &s, const AbstractMetaEnum &cppEnum,
-                                            const QString &pyOpName, const QString &cppOpName)
-{
-    FlagsTypeEntryPtr flagsEntry = cppEnum.typeEntry()->flags();
-    Q_ASSERT(!flagsEntry.isNull());
-
-    s << "PyObject *" << cpythonEnumName(cppEnum) << "___" << pyOpName
-        << "__(PyObject *self, PyObject *" << PYTHON_ARG << ")\n{\n" << indent;
-
-    AbstractMetaType flagsType = AbstractMetaType::fromTypeEntry(flagsEntry);
-    s << "::" << flagsEntry->originalName() << " cppResult, " << CPP_SELF_VAR
-        << ", cppArg;\n"
-        << CPP_SELF_VAR << " = static_cast<::" << flagsEntry->originalName()
-        << ">(int(PyLong_AsLong(self)));\n"
-        // PYSIDE-1436: Need to error check self as well because operators are used
-        //              sometimes with swapped args.
-        << "if (PyErr_Occurred())\n" << indent
-            << "return nullptr;\n" << outdent
-        << "cppArg = static_cast<" << flagsEntry->originalName()
-        << ">(int(PyLong_AsLong(" << PYTHON_ARG << ")));\n"
-        << "if (PyErr_Occurred())\n" << indent
-            << "return nullptr;\n" << outdent
-        << "cppResult = " << CPP_SELF_VAR << " " << cppOpName << " cppArg;\n"
-        << "return ";
-    writeToPythonConversion(s, flagsType, nullptr, u"cppResult"_s);
-    s << ";\n" << outdent << "}\n\n";
-}
-
-void CppGenerator::writeFlagsUnaryOperator(TextStream &s, const AbstractMetaEnum &cppEnum,
-                                           const QString &pyOpName,
-                                           const QString &cppOpName, bool boolResult)
-{
-    FlagsTypeEntryPtr flagsEntry = cppEnum.typeEntry()->flags();
-    Q_ASSERT(flagsEntry);
-
-    s << "PyObject *" << cpythonEnumName(cppEnum) << "___" << pyOpName
-        << "__(PyObject *self, PyObject *" << PYTHON_ARG << ")\n{\n" << indent;
-    if (cppOpName == u"~")
-        s << sbkUnusedVariableCast(PYTHON_ARG);
-
-    AbstractMetaType flagsType = AbstractMetaType::fromTypeEntry(flagsEntry);
-    s << "::" << flagsEntry->originalName() << " " << CPP_SELF_VAR << ";\n"
-        << cpythonToCppConversionFunction(flagsType) << "self, &" << CPP_SELF_VAR
-        << ");\n";
-    if (boolResult)
-        s << "bool";
-    else
-        s << "::" << flagsEntry->originalName();
-    s << " cppResult = " << cppOpName << CPP_SELF_VAR << ";\n"
-        << "return ";
-    if (boolResult)
-        s << "PyBool_FromLong(cppResult)";
-    else
-        writeToPythonConversion(s, flagsType, nullptr, u"cppResult"_s);
-    s << ";\n" << outdent << "}\n\n";
-}
-
-QString CppGenerator::getSimpleClassInitFunctionName(const AbstractMetaClass *metaClass)
+QString CppGenerator::getSimpleClassInitFunctionName(const AbstractMetaClassCPtr &metaClass)
 {
     QString initFunctionName;
     // Disambiguate namespaces per module to allow for extending them.
@@ -5941,7 +5416,8 @@ QString CppGenerator::getSimpleClassInitFunctionName(const AbstractMetaClass *me
     return initFunctionName;
 }
 
-QString CppGenerator::getSimpleClassStaticFieldsInitFunctionName(const AbstractMetaClass *metaClass)
+QString
+    CppGenerator::getSimpleClassStaticFieldsInitFunctionName(const AbstractMetaClassCPtr &metaClass)
 {
     return u"init_"_s + getSimpleClassInitFunctionName(metaClass)
         + u"StaticFields"_s;
@@ -5972,8 +5448,8 @@ void CppGenerator::writeSignatureStrings(TextStream &s,
 }
 
 // Return the class name for which to invoke the destructor
-QString CppGenerator::destructorClassName(const AbstractMetaClass *metaClass,
-                                          const GeneratorContext &classContext) const
+QString CppGenerator::destructorClassName(const AbstractMetaClassCPtr &metaClass,
+                                          const GeneratorContext &classContext)
 {
     if (metaClass->isNamespace() || metaClass->hasPrivateDestructor())
         return {};
@@ -5990,14 +5466,69 @@ QString CppGenerator::destructorClassName(const AbstractMetaClass *metaClass,
     return metaClass->qualifiedCppName();
 }
 
+// Return the base type entries for introduceWrapperType()
+static ComplexTypeEntryCList pyBaseTypeEntries(const AbstractMetaClassCPtr &metaClass)
+{
+    ComplexTypeEntryCList result;
+    if (metaClass->isNamespace()) {
+        if (auto extended = metaClass->extendedNamespace())
+            result.append(extended->typeEntry());
+        return result;
+    }
+
+    const auto &baseClasses = metaClass->typeSystemBaseClasses();
+    for (auto base : baseClasses) {
+        for (; base != nullptr; base = base->baseClass()) { // Find a type that is not disabled.
+            const auto ct = base->typeEntry()->codeGeneration();
+            if (ct == TypeEntry::GenerateCode || ct == TypeEntry::GenerateForSubclass)
+                break;
+        }
+        result.append(base->typeEntry());
+    }
+    return result;
+}
+
+// Return the base type strings for introduceWrapperType()
+QStringList CppGenerator::pyBaseTypes(const AbstractMetaClassCPtr &metaClass)
+{
+    const auto &baseEntries = pyBaseTypeEntries(metaClass);
+    QStringList result;
+    for (const auto &baseEntry : baseEntries)
+        result.append("reinterpret_cast<PyObject *>("_L1 + cpythonTypeNameExt(baseEntry) + u')');
+    if (result.isEmpty()) // no base classes -> SbkObjectType.
+        result.append(sbkObjectTypeF);
+    return result;
+}
+
+void CppGenerator::writeInitInheritance(TextStream &s) const
+{
+    s << "static void " << initInheritanceFunction << "()\n{\n" << indent
+        << "auto &bm = Shiboken::BindingManager::instance();\n"
+        << sbkUnusedVariableCast("bm");
+    for (const auto &cls : api().classes()){
+        auto te = cls->typeEntry();
+        if (shouldGenerate(te)) {
+            const auto &baseEntries = pyBaseTypeEntries(cls);
+            if (!baseEntries.isEmpty()) {
+                const QString childTypeInitStruct = typeInitStruct(cls->typeEntry());
+                for (const auto &baseEntry : baseEntries) {
+                    s << "bm.addClassInheritance(&" << typeInitStruct(baseEntry) << ",\n"
+                      << Pad(' ', 23) << '&' << childTypeInitStruct << ");\n";
+                }
+            }
+        }
+    }
+    s << outdent << "}\n\n";
+}
+
 void CppGenerator::writeClassRegister(TextStream &s,
-                                      const AbstractMetaClass *metaClass,
+                                      const AbstractMetaClassCPtr &metaClass,
                                       const GeneratorContext &classContext,
                                       const QString &signatures) const
 {
     ComplexTypeEntryCPtr classTypeEntry = metaClass->typeEntry();
 
-    const AbstractMetaClass *enc = metaClass->targetLangEnclosingClass();
+    AbstractMetaClassCPtr enc = metaClass->targetLangEnclosingClass();
     QString enclosingObjectVariable = enc ? u"enclosingClass"_s : u"module"_s;
 
     QString pyTypeName = cpythonTypeName(metaClass);
@@ -6005,23 +5536,26 @@ void CppGenerator::writeClassRegister(TextStream &s,
 
     // PYSIDE-510: Create a signatures string for the introspection feature.
     writeSignatureStrings(s, signatures, initFunctionName, "functions");
-    s << "void init_" << initFunctionName;
-    s << "(PyObject *" << enclosingObjectVariable << ")\n{\n" << indent;
+    s << "PyTypeObject *init_" << initFunctionName
+        << "(PyObject *" << enclosingObjectVariable << ")\n{\n" << indent;
+
+    const QString globalTypeVarExpr = !classContext.forSmartPointer()
+                                      ? cpythonTypeNameExtSet(classTypeEntry)
+                                      : cpythonTypeNameExtSet(classContext.preciseType());
+    s << "if (" << globalTypeVarExpr << " != nullptr)\n" << indent
+        << "return " << globalTypeVarExpr << ";\n\n" << outdent;
 
     // Multiple inheritance
     QString pyTypeBasesVariable = chopType(pyTypeName) + u"_Type_bases"_s;
-    const auto &baseClasses = metaClass->typeSystemBaseClasses();
-    if (metaClass->baseClassNames().size() > 1) {
-        s << "PyObject *" << pyTypeBasesVariable
-            << " = PyTuple_Pack(" << baseClasses.size() << ',' << '\n' << indent;
-        for (qsizetype i = 0, size = baseClasses.size(); i < size; ++i) {
-            if (i)
-                s << ",\n";
-            s << "reinterpret_cast<PyObject *>("
-                << cpythonTypeNameExt(baseClasses.at(i)->typeEntry()) << ')';
-        }
-        s << ");\n\n" << outdent;
+    const QStringList pyBases = pyBaseTypes(metaClass);
+    s << "Shiboken::AutoDecRef " << pyTypeBasesVariable << "(PyTuple_Pack("
+        << pyBases.size() << ",\n" << indent;
+    for (qsizetype i = 0, size = pyBases.size(); i < size; ++i) {
+        if (i)
+            s << ",\n";
+        s << pyBases.at(i);
     }
+    s << "));\n\n" << outdent;
 
     // Create type and insert it in the module or enclosing class.
     const QString typePtr = u"_"_s + chopType(pyTypeName)
@@ -6053,29 +5587,11 @@ void CppGenerator::writeClassRegister(TextStream &s,
     if (dtorClassName.isEmpty())
         s << "nullptr,\n";
     else
-        s << "&Shiboken::callCppDestructor< ::" << dtorClassName << " >,\n";
-
-    // 6:baseType: Find a type that is not disabled.
-    auto base = metaClass->isNamespace()
-        ? metaClass->extendedNamespace() : metaClass->baseClass();
-    if (!metaClass->isNamespace()) {
-        for (; base != nullptr; base = base->baseClass()) {
-            const auto ct = base->typeEntry()->codeGeneration();
-            if (ct == TypeEntry::GenerateCode || ct == TypeEntry::GenerateForSubclass)
-                break;
-        }
-    }
-    if (base) {
-        s << cpythonTypeNameExt(base->typeEntry()) << ",\n";
-    } else {
-        s << "0,\n";
-    }
+        s << "&Shiboken::callCppDestructor< " << globalScopePrefix(classContext)
+            << dtorClassName << " >,\n";
 
     // 7:baseTypes
-    if (metaClass->baseClassNames().size() > 1)
-        s << pyTypeBasesVariable << ',' << '\n';
-    else
-        s << "0,\n";
+    s << pyTypeBasesVariable << ".object()," << '\n';
 
     // 8:wrapperflags
     QByteArrayList wrapperFlags;
@@ -6083,6 +5599,8 @@ void CppGenerator::writeClassRegister(TextStream &s,
         wrapperFlags.append(QByteArrayLiteral("Shiboken::ObjectType::WrapperFlags::InnerClass"));
     if (metaClass->deleteInMainThread())
         wrapperFlags.append(QByteArrayLiteral("Shiboken::ObjectType::WrapperFlags::DeleteInMainThread"));
+    if (classTypeEntry->isValue())
+        wrapperFlags.append("Shiboken::ObjectType::WrapperFlags::Value"_ba);
     if (wrapperFlags.isEmpty())
         s << '0';
     else
@@ -6095,16 +5613,15 @@ void CppGenerator::writeClassRegister(TextStream &s,
     if (usePySideExtensions() && !classContext.forSmartPointer())
         s << "SbkObjectType_SetPropertyStrings(pyType, "
                     << chopType(pyTypeName) << "_PropertyStrings);\n";
-
-    if (!classContext.forSmartPointer())
-        s << cpythonTypeNameExt(classTypeEntry) << " = pyType;\n\n";
-    else
-        s << cpythonTypeNameExt(classContext.preciseType()) << " = pyType;\n\n";
+    s << globalTypeVarExpr << " = pyType;\n\n";
 
     // Register conversions for the type.
     writeConverterRegister(s, metaClass, classContext);
     s << '\n';
 
+    if (classContext.forSmartPointer())
+        writeSmartPointerConverterInitialization(s, classContext.preciseType());
+
     // class inject-code target/beginning
     if (!classTypeEntry->codeSnips().isEmpty()) {
         writeClassCodeSnips(s, classTypeEntry->codeSnips(),
@@ -6114,7 +5631,7 @@ void CppGenerator::writeClassRegister(TextStream &s,
     }
 
     // Fill multiple inheritance data, if needed.
-    const AbstractMetaClass *miClass = getMultipleInheritingClass(metaClass);
+    const auto miClass = getMultipleInheritingClass(metaClass);
     if (miClass) {
         s << "MultipleInheritanceInitFunction func = ";
         if (miClass == metaClass) {
@@ -6131,8 +5648,9 @@ void CppGenerator::writeClassRegister(TextStream &s,
 
     // Set typediscovery struct or fill the struct of another one
     if (needsTypeDiscoveryFunction(metaClass)) {
-        s << "Shiboken::ObjectType::setTypeDiscoveryFunctionV2(" << cpythonTypeName(metaClass)
-            << ", &" << cpythonBaseName(metaClass) << "_typeDiscovery);\n\n";
+        s << "Shiboken::ObjectType::setTypeDiscoveryFunctionV2(\n" << indent
+            << cpythonTypeName(metaClass)
+            << ", &" << cpythonBaseName(metaClass) << "_typeDiscovery);" << outdent << "\n\n";
     }
 
     AbstractMetaEnumList classEnums = metaClass->enums();
@@ -6142,7 +5660,7 @@ void CppGenerator::writeClassRegister(TextStream &s,
         s << "// Pass the ..._EnumFlagInfo to the class.\n"
             << "SbkObjectType_SetEnumFlagInfo(pyType, " << chopType(pyTypeName)
             << "_EnumFlagInfo);\n\n";
-    writeEnumsInitialization(s, classEnums, ErrorReturn::Void);
+    writeEnumsInitialization(s, classEnums);
 
     if (metaClass->hasSignals())
         writeSignalInitialization(s, metaClass);
@@ -6162,25 +5680,40 @@ void CppGenerator::writeClassRegister(TextStream &s,
             writeInitQtMetaTypeFunctionBody(s, classContext);
     }
 
-    if (usePySideExtensions() && metaClass->isQObject()) {
+    if (usePySideExtensions() && isQObject(metaClass)) {
         s << "Shiboken::ObjectType::setSubTypeInitHook(pyType, &PySide::initQObjectSubType);\n"
-            << "PySide::initDynamicMetaObject(pyType, &::"
-            << metaClass->qualifiedCppName() << "::staticMetaObject, sizeof(";
-        if (shouldGenerateCppWrapper(metaClass))
-            s << wrapperName(metaClass);
-        else
-            s << "::" << metaClass->qualifiedCppName();
-        s << "));\n";
+          << "PySide::initDynamicMetaObject(pyType, &" << m_gsp
+            << metaClass->qualifiedCppName() << "::staticMetaObject, sizeof("
+            << (shouldGenerateCppWrapper(metaClass)
+                ? wrapperName(metaClass) : getFullTypeName(metaClass))
+            << "));\n";
     }
 
-    s << outdent << "}\n";
+    s << "\nreturn pyType;\n" << outdent << "}\n";
 }
 
-void CppGenerator::writeStaticFieldInitialization(TextStream &s, const AbstractMetaClass *metaClass)
+void CppGenerator::writeStaticFieldInitialization(TextStream &s,
+                                                  const AbstractMetaClassCPtr &metaClass)
 {
-    s << "\nvoid " << getSimpleClassStaticFieldsInitFunctionName(metaClass)
-        << "()\n{\n" << indent << "auto dict = reinterpret_cast<PyTypeObject *>("
-        << cpythonTypeName(metaClass) << ")->tp_dict;\n";
+    // cpythonTypeName == "Sbk_QRhiShaderResourceBinding_Data_TypeF"
+    QString name = cpythonTypeName(metaClass);
+    const auto parts = QStringView{name}.split(u'_', Qt::SkipEmptyParts);
+    if (parts.size() < 4) {
+        s << "\nPyTypeObject *" << getSimpleClassStaticFieldsInitFunctionName(metaClass)
+            << "(PyObject *module)\n{\n" << indent
+            << "auto *obType = PyObject_GetAttrString(module, \"" << metaClass->name() << "\");\n"
+            << "auto *type = reinterpret_cast<PyTypeObject *>(obType);\n"
+            << "Shiboken::AutoDecRef dict(PepType_GetDict(type));\n";
+    } else {
+        s << "\nPyTypeObject *" << getSimpleClassStaticFieldsInitFunctionName(metaClass)
+            << "(PyObject *module)\n{\n" << indent
+            << "auto *obContainerType = PyObject_GetAttrString(module, \""
+            << parts.at(1) << "\");\n"
+            << "auto *obType = PyObject_GetAttrString(obContainerType, \""
+            << parts.at(2) << "\");\n"
+            << "auto *type = reinterpret_cast<PyTypeObject *>(obType);\n"
+            << "Shiboken::AutoDecRef dict(PepType_GetDict(type));\n";
+    }
     for (const AbstractMetaField &field : metaClass->fields()) {
         if (field.isStatic()) {
             s << "PyDict_SetItemString(dict, \"" << field.name()
@@ -6189,7 +5722,7 @@ void CppGenerator::writeStaticFieldInitialization(TextStream &s, const AbstractM
             s << ");\n";
         }
     }
-    s << '\n' << outdent << "}\n";
+    s << "return type;\n" << outdent << "}\n";
 }
 
 enum class QtRegisterMetaType
@@ -6197,7 +5730,7 @@ enum class QtRegisterMetaType
     None, Pointer, Value
 };
 
-static bool hasQtMetaTypeRegistrationSpec(const AbstractMetaClass *c)
+static bool hasQtMetaTypeRegistrationSpec(const AbstractMetaClassCPtr &c)
 {
     return c->typeEntry()->qtMetaTypeRegistration() !=
            TypeSystem::QtMetaTypeRegistration::Unspecified;
@@ -6206,7 +5739,7 @@ static bool hasQtMetaTypeRegistrationSpec(const AbstractMetaClass *c)
 // Returns if and how to register the Qt meta type. By default, "pointer" for
 // non-QObject object types and "value" for non-abstract, default-constructible
 // value types.
-QtRegisterMetaType qtMetaTypeRegistration(const AbstractMetaClass *c)
+QtRegisterMetaType qtMetaTypeRegistration(const AbstractMetaClassCPtr &c)
 {
     if (c->isNamespace())
         return QtRegisterMetaType::None;
@@ -6225,7 +5758,7 @@ QtRegisterMetaType qtMetaTypeRegistration(const AbstractMetaClass *c)
 
     // Is there a "base" specification in some base class, meaning only the
     // base class is to be registered?
-    if (auto *base = recurseClassHierarchy(c, hasQtMetaTypeRegistrationSpec)) {
+    if (auto base = recurseClassHierarchy(c, hasQtMetaTypeRegistrationSpec)) {
         const auto baseSpec = base->typeEntry()->qtMetaTypeRegistration();
         if (baseSpec == TypeSystem::QtMetaTypeRegistration::BaseEnabled)
             return QtRegisterMetaType::None;
@@ -6233,7 +5766,7 @@ QtRegisterMetaType qtMetaTypeRegistration(const AbstractMetaClass *c)
 
     // Default.
     if (isObject)
-        return c->isQObject() ? QtRegisterMetaType::None : QtRegisterMetaType::Pointer;
+        return isQObject(c) ? QtRegisterMetaType::None : QtRegisterMetaType::Pointer;
 
     return !c->isAbstract() && c->isDefaultConstructible()
         ? QtRegisterMetaType::Value : QtRegisterMetaType::None;
@@ -6241,7 +5774,7 @@ QtRegisterMetaType qtMetaTypeRegistration(const AbstractMetaClass *c)
 
 void CppGenerator::writeInitQtMetaTypeFunctionBody(TextStream &s, const GeneratorContext &context)
 {
-    const AbstractMetaClass *metaClass = context.metaClass();
+    const auto metaClass = context.metaClass();
     // Gets all class name variants used on different possible scopes
     QStringList nameVariants;
     if (!context.forSmartPointer())
@@ -6249,7 +5782,7 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(TextStream &s, const Generato
     else
         nameVariants << context.preciseType().cppSignature();
 
-    const AbstractMetaClass *enclosingClass = metaClass->enclosingClass();
+    AbstractMetaClassCPtr enclosingClass = metaClass->enclosingClass();
     while (enclosingClass) {
         if (enclosingClass->typeEntry()->generateCode())
             nameVariants << (enclosingClass->name() + u"::"_s + nameVariants.constLast());
@@ -6268,55 +5801,67 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(TextStream &s, const Generato
     case QtRegisterMetaType::None:
         break;
     case QtRegisterMetaType::Pointer:
-        s << "qRegisterMetaType< ::" << className << " *>();\n";
+        s << "qRegisterMetaType< " << m_gsp << className << " *>();\n";
         break;
     case QtRegisterMetaType::Value:
         for (const QString &name : std::as_const(nameVariants))
-            s << "qRegisterMetaType< ::" << className << " >(\"" << name << "\");\n";
+            s << "qRegisterMetaType< " << m_gsp << className << " >(\"" << name << "\");\n";
         break;
     }
 
     for (const AbstractMetaEnum &metaEnum : metaClass->enums()) {
         if (!metaEnum.isPrivate() && !metaEnum.isAnonymous()) {
             for (const QString &name : std::as_const(nameVariants)) {
-                s << "qRegisterMetaType< ::"
+                s << "qRegisterMetaType< " << m_gsp
                     << metaEnum.typeEntry()->qualifiedCppName() << " >(\""
                     << name << "::" << metaEnum.name() << "\");\n";
             }
-            if (metaEnum.typeEntry()->flags()) {
-                QString n = metaEnum.typeEntry()->flags()->originalName();
-                s << "qRegisterMetaType< ::" << n << " >(\"" << n << "\");\n";
-            }
         }
     }
 }
 
-void CppGenerator::writeTypeDiscoveryFunction(TextStream &s, const AbstractMetaClass *metaClass)
+void CppGenerator::replacePolymorphicIdPlaceHolders(const AbstractMetaClassCPtr &metaClass,
+                                                    QString *id)
+{
+    if (id->contains("%1"_L1)) {
+        QString replacement = " reinterpret_cast< "_L1 + m_gsp + metaClass->qualifiedCppName()
+                              + " *>(cptr)"_L1;
+        id->replace("%1"_L1, replacement);
+    }
+    if (id->contains("%B"_L1)) {
+        auto baseClass = metaClass;
+        while (!baseClass->typeEntry()->isPolymorphicBase() && baseClass->baseClass())
+            baseClass = baseClass->baseClass();
+        QString replacement = " reinterpret_cast< "_L1 + m_gsp + baseClass->qualifiedCppName()
+                              + " *>(cptr)"_L1;
+        id->replace("%B"_L1, replacement);
+    }
+}
+
+void CppGenerator::writeTypeDiscoveryFunction(TextStream &s,
+                                              const AbstractMetaClassCPtr &metaClass)
 {
     QString polymorphicExpr = metaClass->typeEntry()->polymorphicIdValue();
 
     s << "static void *" << cpythonBaseName(metaClass)
         << "_typeDiscovery(void *cptr, PyTypeObject *instanceType)\n{\n" << indent
-        << sbkUnusedVariableCast(u"cptr"_s)
-        << sbkUnusedVariableCast(u"instanceType"_s);
+        << sbkUnusedVariableCast("cptr")
+        << sbkUnusedVariableCast("instanceType");
 
     if (!polymorphicExpr.isEmpty()) {
-        polymorphicExpr = polymorphicExpr.replace(u"%1"_s,
-                                                  u" reinterpret_cast< ::"_s
-                                                  + metaClass->qualifiedCppName()
-                                                  + u" *>(cptr)"_s);
-        s << " if (" << polymorphicExpr << ")\n" << indent
+        replacePolymorphicIdPlaceHolders(metaClass, &polymorphicExpr);
+        s << "if (" << polymorphicExpr << ")\n" << indent
             << "return cptr;\n" << outdent;
     } else if (metaClass->isPolymorphic()) {
         const auto &ancestors = metaClass->allTypeSystemAncestors();
-        for (auto *ancestor : ancestors) {
-            if (ancestor->baseClass())
+        for (const auto &ancestor : ancestors) {
+            if (ancestor->baseClass() && !ancestor->typeEntry()->isPolymorphicBase())
                 continue;
             if (ancestor->isPolymorphic()) {
-                s << "if (instanceType == Shiboken::SbkType< ::"
+                s << "if (instanceType == Shiboken::SbkType< " << m_gsp
                     << ancestor->qualifiedCppName() << " >())\n" << indent
-                    << "return dynamic_cast< ::" << metaClass->qualifiedCppName()
-                    << " *>(reinterpret_cast< ::"<< ancestor->qualifiedCppName()
+                    << "return dynamic_cast< " << getFullTypeName(metaClass)
+                    << " *>(reinterpret_cast< "<< getFullTypeName(ancestor)
                     << " *>(cptr));\n" << outdent;
             } else {
                 qCWarning(lcShiboken).noquote().nospace()
@@ -6330,7 +5875,8 @@ void CppGenerator::writeTypeDiscoveryFunction(TextStream &s, const AbstractMetaC
     s << "return {};\n" << outdent << "}\n\n";
 }
 
-void CppGenerator::writeSetattroDefinition(TextStream &s, const AbstractMetaClass *metaClass) const
+void CppGenerator::writeSetattroDefinition(TextStream &s,
+                                           const AbstractMetaClassCPtr &metaClass)
 {
     s << "static int " << ShibokenGenerator::cpythonSetattroFunctionName(metaClass)
         << "(PyObject *self, PyObject *name, PyObject *value)\n{\n" << indent;
@@ -6340,7 +5886,7 @@ void CppGenerator::writeSetattroDefinition(TextStream &s, const AbstractMetaClas
     }
 }
 
-inline void CppGenerator::writeSetattroDefaultReturn(TextStream &s)
+void CppGenerator::writeSetattroDefaultReturn(TextStream &s)
 {
     s << "return PyObject_GenericSetAttr(self, name, value);\n"
         << outdent << "}\n\n";
@@ -6350,7 +5896,7 @@ void CppGenerator::writeSetattroFunction(TextStream &s, AttroCheck attroCheck,
                                          const GeneratorContext &context) const
 {
     Q_ASSERT(!context.forSmartPointer());
-    const AbstractMetaClass *metaClass = context.metaClass();
+    const auto metaClass = context.metaClass();
     writeSetattroDefinition(s, metaClass);
 
     // PYSIDE-1019: Switch tp_dict before doing tp_setattro.
@@ -6360,10 +5906,10 @@ void CppGenerator::writeSetattroFunction(TextStream &s, AttroCheck attroCheck,
     // PYSIDE-803: Detect duck-punching; clear cache if a method is set.
     if (attroCheck.testFlag(AttroCheckFlag::SetattroMethodOverride)
             && context.useWrapper()) {
-        s << "if (value && PyCallable_Check(value)) {\n" << indent
-            << "auto plain_inst = " << cpythonWrapperCPtr(metaClass, u"self"_s) << ";\n"
-            << "auto inst = dynamic_cast<" << context.wrapperName() << " *>(plain_inst);\n"
-            << "if (inst)\n" << indent
+        s << "if (value != nullptr && PyCallable_Check(value) != 0) {\n" << indent
+            << "auto plain_inst = " << cpythonWrapperCPtr(metaClass, PYTHON_SELF_VAR) << ";\n"
+            << "auto *inst = dynamic_cast<" << context.wrapperName() << " *>(plain_inst);\n"
+            << "if (inst != nullptr)\n" << indent
             << "inst->resetPyMethodCache();\n" << outdent << outdent
             << "}\n";
     }
@@ -6380,7 +5926,7 @@ void CppGenerator::writeSetattroFunction(TextStream &s, AttroCheck attroCheck,
         Q_ASSERT(func);
         s << "{\n" << indent
             << "auto " << CPP_SELF_VAR << " = "
-            << cpythonWrapperCPtr(metaClass, u"self"_s) << ";\n";
+            << cpythonWrapperCPtr(metaClass, PYTHON_SELF_VAR) << ";\n";
         writeClassCodeSnips(s, func->injectedCodeSnips(), TypeSystem::CodeSnipPositionAny,
                             TypeSystem::TargetLangCode, context);
         s << outdent << "}\n";
@@ -6389,26 +5935,7 @@ void CppGenerator::writeSetattroFunction(TextStream &s, AttroCheck attroCheck,
     writeSetattroDefaultReturn(s);
 }
 
-static const char smartPtrComment[] =
-   "// Try to find the 'name' attribute, by retrieving the PyObject for "
-   "the corresponding C++ object held by the smart pointer.\n";
-
-void CppGenerator::writeSmartPointerSetattroFunction(TextStream &s,
-                                                     const GeneratorContext &context) const
-{
-    Q_ASSERT(context.forSmartPointer());
-    writeSetattroDefinition(s, context.metaClass());
-    s << smartPtrComment
-        << "if (auto *rawObj = PyObject_CallMethod(self, " << SMART_POINTER_GETTER
-        << ", 0)) {\n" << indent
-        << "if (PyObject_HasAttr(rawObj, name) != 0)\n" << indent
-        << "return PyObject_GenericSetAttr(rawObj, name, value);\n" << outdent
-        << "Py_DECREF(rawObj);\n" << outdent
-        << "}\n";
-    writeSetattroDefaultReturn(s);
-}
-
-void CppGenerator::writeGetattroDefinition(TextStream &s, const AbstractMetaClass *metaClass)
+void CppGenerator::writeGetattroDefinition(TextStream &s, const AbstractMetaClassCPtr &metaClass)
 {
     s << "static PyObject *" << cpythonGetattroFunctionName(metaClass)
         << "(PyObject *self, PyObject *name)\n{\n" << indent;
@@ -6418,10 +5945,10 @@ QString CppGenerator::qObjectGetAttroFunction() const
 {
     static QString result;
     if (result.isEmpty()) {
-        auto qobjectClass = AbstractMetaClass::findClass(api().classes(), qObjectT());
+        auto qobjectClass = AbstractMetaClass::findClass(api().classes(), qObjectT);
         Q_ASSERT(qobjectClass);
-        result = u"PySide::getMetaDataFromQObject("_s
-                 + cpythonWrapperCPtr(qobjectClass, u"self"_s)
+        result = u"PySide::getHiddenDataFromQObject("_s
+                 + cpythonWrapperCPtr(qobjectClass, PYTHON_SELF_VAR)
                  + u", self, name)"_s;
     }
     return result;
@@ -6431,14 +5958,14 @@ void CppGenerator::writeGetattroFunction(TextStream &s, AttroCheck attroCheck,
                                          const GeneratorContext &context) const
 {
     Q_ASSERT(!context.forSmartPointer());
-    const AbstractMetaClass *metaClass = context.metaClass();
+    const auto metaClass = context.metaClass();
     writeGetattroDefinition(s, metaClass);
 
     // PYSIDE-1019: Switch tp_dict before doing tp_getattro.
     if (usePySideExtensions())
         s << "PySide::Feature::Select(self);\n";
 
-    const QString getattrFunc = usePySideExtensions() && metaClass->isQObject()
+    const QString getattrFunc = usePySideExtensions() && isQObject(metaClass)
         ? qObjectGetAttroFunction() : u"PyObject_GenericGetAttr(self, name)"_s;
 
     if (attroCheck.testFlag(AttroCheckFlag::GetattroOverloads)) {
@@ -6450,11 +5977,14 @@ void CppGenerator::writeGetattroFunction(TextStream &s, AttroCheck attroCheck,
             << "if (Shiboken::Object::isUserType(self)) {\n" << indent;
         // PYSIDE-772: Perform optimized name mangling.
         s << "Shiboken::AutoDecRef tmp(_Pep_PrivateMangle(self, name));\n"
-            << "if (auto *meth = PyDict_GetItem(Py_TYPE(self)->tp_dict, tmp)) {\n" << indent;
+            << "Shiboken::AutoDecRef tpDict(PepType_GetDict(Py_TYPE(self)));\n"
+            << "if (auto *meth = PyDict_GetItem(tpDict.object(), tmp)) {\n" << indent;
         // PYSIDE-1523: PyFunction_Check is not accepting compiled functions.
-        s << "if (std::strcmp(Py_TYPE(meth)->tp_name, \"compiled_function\") == 0)\n" << indent
-            << "return Py_TYPE(meth)->tp_descr_get(meth, self, nullptr);\n" << outdent
-            << "return PyFunction_Check(meth) ? PyMethod_New(meth, self)\n"
+        s << "if (std::strcmp(Py_TYPE(meth)->tp_name, \"compiled_function\") == 0) {\n" << indent
+            << "auto descrGetFunc = "
+            << pyTypeGetSlot("descrgetfunc", "Py_TYPE(meth)", "Py_tp_descr_get") << ";\n"
+            << "return descrGetFunc(meth, self, nullptr);\n" << outdent
+            << "}\nreturn PyFunction_Check(meth) ? PyMethod_New(meth, self)\n"
             << "                              : " << getattrFunc << ";\n" << outdent
             << "}\n" << outdent << "}\n";
 
@@ -6480,7 +6010,7 @@ void CppGenerator::writeGetattroFunction(TextStream &s, AttroCheck attroCheck,
         Q_ASSERT(func);
         s << "{\n" << indent
             << "auto " << CPP_SELF_VAR << " = "
-            << cpythonWrapperCPtr(metaClass, u"self"_s) << ";\n";
+            << cpythonWrapperCPtr(metaClass, PYTHON_SELF_VAR) << ";\n";
         writeClassCodeSnips(s, func->injectedCodeSnips(), TypeSystem::CodeSnipPositionAny,
                             TypeSystem::TargetLangCode, context);
         s << outdent << "}\n";
@@ -6489,50 +6019,6 @@ void CppGenerator::writeGetattroFunction(TextStream &s, AttroCheck attroCheck,
     s << "return " << getattrFunc << ";\n" << outdent << "}\n\n";
 }
 
-void CppGenerator::writeSmartPointerGetattroFunction(TextStream &s,
-                                                     const GeneratorContext &context,
-                                                     const BoolCastFunctionOptional &boolCast)
-{
-    Q_ASSERT(context.forSmartPointer());
-    const AbstractMetaClass *metaClass = context.metaClass();
-    writeGetattroDefinition(s, metaClass);
-    s << "PyObject *tmp = PyObject_GenericGetAttr(self, name);\n"
-        << "if (tmp)\n" << indent << "return tmp;\n" << outdent
-        << "if (PyErr_ExceptionMatches(PyExc_AttributeError) == 0)\n"
-        << indent << "return nullptr;\n" << outdent
-        << "PyErr_Clear();\n";
-
-    if (boolCast.has_value()) {
-        writeSmartPointerCppSelfDefinition(s, context);
-        s << "if (";
-        writeNbBoolExpression(s, boolCast.value(), true /* invert */);
-        s << ") {\n" << indent
-          << R"(PyTypeObject *tp = Py_TYPE(self);
-PyErr_Format(PyExc_AttributeError, "Attempt to retrieve '%s' from null object '%s'.",
-             Shiboken::String::toCString(name), tp->tp_name);
-return nullptr;
-)" << outdent << "}\n";
-    }
-
-    // This generates the code which dispatches access to member functions
-    // and fields from the smart pointer to its pointee.
-    s << smartPtrComment
-        << "if (auto *rawObj = PyObject_CallMethod(self, "
-        << SMART_POINTER_GETTER << ", 0)) {\n" << indent
-        << "if (auto *attribute = PyObject_GetAttr(rawObj, name))\n"
-        << indent << "tmp = attribute;\n" << outdent
-        << "Py_DECREF(rawObj);\n" << outdent
-        << "}\n"
-        << "if (!tmp) {\n" << indent
-        << R"(PyTypeObject *tp = Py_TYPE(self);
-PyErr_Format(PyExc_AttributeError,
-             "'%.50s' object has no attribute '%.400s'",
-             tp->tp_name, Shiboken::String::toCString(name));
-)" << outdent
-        << "}\n"
-        << "return tmp;\n" << outdent << "}\n\n";
-}
-
 void CppGenerator::writeNbBoolExpression(TextStream &s, const BoolCastFunction &f,
                                          bool invert)
 {
@@ -6549,7 +6035,7 @@ void CppGenerator::writeNbBoolExpression(TextStream &s, const BoolCastFunction &
 
 void CppGenerator::writeNbBoolFunction(const GeneratorContext &context,
                                        const BoolCastFunction &f,
-                                       TextStream &s) const
+                                       TextStream &s)
 {
     s << "static int " << cpythonBaseName(context.metaClass()) << "___nb_bool(PyObject *self)\n"
       << "{\n" << indent;
@@ -6571,30 +6057,59 @@ void CppGenerator::writeNbBoolFunction(const GeneratorContext &context,
 
 // Write declaration and invocation of the init function for the module init
 // function.
-void CppGenerator::writeInitFunc(TextStream &declStr, TextStream &callStr,
-                                 const QString &initFunctionName,
-                                 const TypeEntryCPtr &enclosingEntry)
-{
-    const bool hasParent =
-        enclosingEntry && enclosingEntry->type() != TypeEntry::TypeSystemType;
-    declStr << "void init_" << initFunctionName << "(PyObject *"
-        << (hasParent ? "enclosingClass" : "module") << ");\n";
-    callStr << "init_" << initFunctionName;
-    if (hasParent) {
-        callStr << "(reinterpret_cast<PyTypeObject *>("
-            << cpythonTypeNameExt(enclosingEntry) << ")->tp_dict);\n";
+static void writeInitFuncDecl(TextStream &declStr,
+                              const QString &functionName)
+{
+    declStr << "PyTypeObject *" << functionName  << "(PyObject *enclosing);\n";
+}
+
+// Write declaration and invocation of the init function for the module init
+// function.
+void CppGenerator::writeInitFuncCall(TextStream &callStr,
+                                     const QString &functionName,
+                                     const TypeEntryCPtr &enclosingEntry,
+                                     const QString &pythonName, bool lazy)
+{
+    const bool hasParent = enclosingEntry && enclosingEntry->type() != TypeEntry::TypeSystemType;
+    if (!lazy) {
+        const QString enclosing = hasParent
+            ? "reinterpret_cast<PyObject *>("_L1 + cpythonTypeNameExt(enclosingEntry) + u')'
+            : "module"_L1;
+        callStr << functionName << '(' << enclosing << ");\n";
+    } else if (hasParent) {
+        const QString &enclosingName = enclosingEntry->name();
+        const auto parts = QStringView{enclosingName}.split(u"::", Qt::SkipEmptyParts);
+        const QString namePathPrefix = enclosingEntry->name().replace("::"_L1, "."_L1);
+        callStr << "Shiboken::Module::AddTypeCreationFunction("
+            << "module, \"" << parts[0] << "\", "
+            << functionName << ", \"" << namePathPrefix << '.' << pythonName << "\");\n";
     } else {
-        callStr << "(module);\n";
+        callStr << "Shiboken::Module::AddTypeCreationFunction("
+            << "module, \"" << pythonName << "\", "
+            << functionName << ");\n";
     }
 }
 
+static void writeSubModuleHandling(TextStream &s, const QString &moduleName,
+                                   const QString &subModuleOf)
+{
+    s << "{\n" << indent
+        << "Shiboken::AutoDecRef parentModule(Shiboken::Module::import(\""
+        << subModuleOf << "\"));\n"
+        << "if (parentModule.isNull())\n" << indent
+        << "return nullptr;\n" << outdent
+        << "if (PyModule_AddObject(parentModule.object(), \"" << moduleName
+        << "\", module) < 0)\n"
+        << indent << "return nullptr;\n" << outdent << outdent << "}\n";
+}
+
 bool CppGenerator::finishGeneration()
 {
     //Generate CPython wrapper file
     StringStream s_classInitDecl(TextStream::Language::Cpp);
     StringStream s_classPythonDefines(TextStream::Language::Cpp);
 
-    QSet<Include> includes;
+    std::set<Include> includes;
     StringStream s_globalFunctionImpl(TextStream::Language::Cpp);
     StringStream s_globalFunctionDef(TextStream::Language::Cpp);
     StringStream signatureStream(TextStream::Language::Cpp);
@@ -6603,8 +6118,8 @@ bool CppGenerator::finishGeneration()
     for (auto it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
         const AbstractMetaFunctionCList &overloads = it.value();
         for (const auto &func : overloads) {
-                if (func->typeEntry())
-                    includes << func->typeEntry()->include();
+            if (auto te = func->typeEntry())
+                includes.insert(te->include());
         }
 
         if (overloads.isEmpty())
@@ -6620,50 +6135,61 @@ bool CppGenerator::finishGeneration()
     }
 
     AbstractMetaClassCList classesWithStaticFields;
-    for (auto cls : api().classes()){
+    for (const auto &cls : api().classes()){
         auto te = cls->typeEntry();
         if (shouldGenerate(te)) {
-            writeInitFunc(s_classInitDecl, s_classPythonDefines,
-                          getSimpleClassInitFunctionName(cls),
-                          targetLangEnclosingEntry(te));
+            const bool hasConfigCondition = te->hasConfigCondition();
+            if (hasConfigCondition) {
+                s_classInitDecl << te->configCondition() << '\n';
+                s_classPythonDefines << te->configCondition() << '\n';
+            }
+            const QString initFunc = initFuncPrefix + getSimpleClassInitFunctionName(cls);
+            writeInitFuncDecl(s_classInitDecl, initFunc);
+            writeInitFuncCall(s_classPythonDefines, initFunc,
+                              targetLangEnclosingEntry(te), cls->name());
             if (cls->hasStaticFields()) {
-                s_classInitDecl << "void "
-                    << getSimpleClassStaticFieldsInitFunctionName(cls) << "();\n";
+                s_classInitDecl << "PyTypeObject *"
+                    << getSimpleClassStaticFieldsInitFunctionName(cls) << "(PyObject *module);\n";
                 classesWithStaticFields.append(cls);
             }
+            if (hasConfigCondition) {
+                s_classInitDecl << "#endif\n";
+                s_classPythonDefines << "#endif\n";
+            }
         }
     }
 
     // Initialize smart pointer types.
     for (const auto &smp : api().instantiatedSmartPointers()) {
         GeneratorContext context = contextForSmartPointer(smp.specialized, smp.type);
-        auto *enclosingClass = context.metaClass()->enclosingClass();
-        auto enclosingTypeEntry = enclosingClass != nullptr
-            ? enclosingClass->typeEntry()
-            : targetLangEnclosingEntry(smp.type.typeEntry());
-        writeInitFunc(s_classInitDecl, s_classPythonDefines,
-                      getInitFunctionName(context),
-                      enclosingTypeEntry);
-        includes << smp.type.instantiations().constFirst().typeEntry()->include();
+        const auto enclosingClass = context.metaClass()->enclosingClass();
+        auto enclosingTypeEntry = targetLangEnclosingEntry(smp.specialized->typeEntry());
+
+        const QString initFunc = initFuncPrefix + getInitFunctionName(context);
+        writeInitFuncDecl(s_classInitDecl, initFunc);
+        writeInitFuncCall(s_classPythonDefines,
+                          initFunc, enclosingTypeEntry, smp.specialized->name());
+        includes.insert(smp.type.instantiations().constFirst().typeEntry()->include());
     }
 
     for (auto &instantiatedContainer : api().instantiatedContainers()) {
+        includes.insert(instantiatedContainer.typeEntry()->include());
         for (const auto &inst : instantiatedContainer.instantiations())
-            includes << inst.typeEntry()->include();
+            includes.insert(inst.typeEntry()->include());
     }
 
     const ExtendedConverterData extendedConverters = getExtendedConverters();
     for (auto it = extendedConverters.cbegin(), end = extendedConverters.cend(); it != end; ++it) {
         TypeEntryCPtr te = it.key();
-        includes << te->include();
+        includes.insert(te->include());
         for (const auto &metaClass : it.value())
-            includes << metaClass->typeEntry()->include();
+            includes.insert(metaClass->typeEntry()->include());
     }
 
     const QList<CustomConversionPtr> &typeConversions = getPrimitiveCustomConversions();
     for (const auto &c : typeConversions) {
-        if (auto te = c->ownerType(); !te.isNull())
-            includes << te->include();
+        if (auto te = c->ownerType())
+            includes.insert(te->include());
     }
 
     QString moduleFileName(outputDirectory() + u'/' + subDirectoryForPackage(packageName()));
@@ -6695,13 +6221,13 @@ bool CppGenerator::finishGeneration()
     }
 
     s << "#include \"" << getModuleHeaderFileName() << '"'  << "\n\n";
-    for (const Include &include : std::as_const(includes))
+    for (const Include &include : includes)
         s << include;
     s << '\n';
 
     // Global enums
     AbstractMetaEnumList globalEnums = api().globalEnums();
-    for (const AbstractMetaClass *nsp : invisibleTopNamespaces()) {
+    for (const auto &nsp : invisibleTopNamespaces()) {
         const auto oldSize = globalEnums.size();
         nsp->getEnumsToBeGenerated(&globalEnums);
         if (globalEnums.size() > oldSize)
@@ -6710,7 +6236,7 @@ bool CppGenerator::finishGeneration()
 
     TypeDatabase *typeDb = TypeDatabase::instance();
     TypeSystemTypeEntryCPtr moduleEntry = typeDb->defaultTypeSystemType();
-    Q_ASSERT(!moduleEntry.isNull());
+    Q_ASSERT(moduleEntry);
 
     s  << '\n';
     // Extra includes
@@ -6725,29 +6251,34 @@ bool CppGenerator::finishGeneration()
         s << '\n';
     }
 
+    // FIXME PYSIDE-7: Remove backwards compatible structure
     s << "// Current module's type array.\n"
-       << "PyTypeObject **" << cppApiVariableName() << " = nullptr;\n"
+       << "Shiboken::Module::TypeInitStruct *" << cppApiVariableName() << " = nullptr;\n"
+       << "// Backwards compatible structure with identical indexing.\n"
+       << "PyTypeObject **" << cppApiVariableNameOld() << " = nullptr;\n"
        << "// Current module's PyObject pointer.\n"
        << "PyObject *" << pythonModuleObjectName() << " = nullptr;\n"
        << "// Current module's converter array.\n"
-       << "SbkConverter **" << convertersVariableName() << " = nullptr;\n";
+       << "SbkConverter **" << convertersVariableName() << " = nullptr;\n\n";
 
     const CodeSnipList snips = moduleEntry->codeSnips();
 
     // module inject-code native/beginning
-    if (!snips.isEmpty())
-        writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode);
+    writeModuleCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode);
 
     // cleanup staticMetaObject attribute
     if (usePySideExtensions()) {
+        QString iType = cppApiVariableName() + "[i].type"_L1;
+        QString iName = cppApiVariableName() + "[i].fullName"_L1;
+
         s << "void cleanTypesAttributes() {\n" << indent
             << "static PyObject *attrName = Shiboken::PyName::qtStaticMetaObject();\n"
-            << "for (int i = 0, imax = SBK_" << moduleName()
-            << "_IDX_COUNT; i < imax; i++) {\n" << indent
-            << "PyObject *pyType = reinterpret_cast<PyObject *>(" << cppApiVariableName() << "[i]);\n"
-            << "if (pyType && PyObject_HasAttr(pyType, attrName))\n" << indent
+            << "const int imax = SBK_" << moduleName() << "_IDX_COUNT;\n"
+            << "for (int i = 0; i < imax && " << iName << " != nullptr; ++i) {\n" << indent
+            << "auto *pyType = reinterpret_cast<PyObject *>(" << iType << ");\n"
+            << "if (pyType != nullptr && PyObject_HasAttr(pyType, attrName))\n" << indent
             << "PyObject_SetAttr(pyType, attrName, Py_None);\n" << outdent
-            << outdent << "}\n" << outdent << "}\n";
+            << outdent << "}\n" << outdent << "}\n\n";
     }
 
     s << "// Global functions "
@@ -6755,7 +6286,7 @@ bool CppGenerator::finishGeneration()
         << s_globalFunctionImpl.toString() << '\n'
         << "static PyMethodDef " << moduleName() << "_methods[] = {\n" << indent
         << s_globalFunctionDef.toString()
-        << methodDefSentinel << outdent << "};\n\n"
+        << METHOD_DEF_SENTINEL << outdent << "};\n\n"
         << "// Classes initialization functions "
         << "------------------------------------------------------------\n"
         << s_classInitDecl.toString() << '\n';
@@ -6776,7 +6307,6 @@ bool CppGenerator::finishGeneration()
                 << "} // namespace Shiboken\n\n";
         }
 
-        writeFlagsNumberMethodsDefinitions(s, globalEnums);
         s << '\n';
     }
 
@@ -6784,7 +6314,7 @@ bool CppGenerator::finishGeneration()
     if (!requiredModules.isEmpty())
         s << "// Required modules' type and converter arrays.\n";
     for (const QString &requiredModule : requiredModules) {
-        s << "PyTypeObject **" << cppApiVariableName(requiredModule) << ";\n"
+        s << "Shiboken::Module::TypeInitStruct *" << cppApiVariableName(requiredModule) << ";\n"
             << "SbkConverter **" << convertersVariableName(requiredModule) << ";\n";
     }
 
@@ -6796,7 +6326,7 @@ bool CppGenerator::finishGeneration()
             TypeEntryCPtr externalType = it.key();
             s << "// Extended implicit conversions for "
                 << externalType->qualifiedTargetLangName() << '.' << '\n';
-            for (const AbstractMetaClass *sourceClass : it.value()) {
+            for (const auto &sourceClass : it.value()) {
                 AbstractMetaType sourceType = AbstractMetaType::fromAbstractMetaClass(sourceClass);
                 AbstractMetaType targetType = AbstractMetaType::fromTypeEntry(externalType);
                 writePythonToCppConversionFunctions(s, sourceType, targetType);
@@ -6816,31 +6346,22 @@ bool CppGenerator::finishGeneration()
 
     QHash<AbstractMetaType, OpaqueContainerData> opaqueContainers;
     const auto &containers = api().instantiatedContainers();
+    QSet<AbstractMetaType> valueConverters;
     if (!containers.isEmpty()) {
         s << "// Container Type converters.\n\n";
         for (const AbstractMetaType &container : containers) {
-            s << "// C++ to Python conversion for container type '" << container.cppSignature() << "'.\n";
+            s << "// C++ to Python conversion for container type '"
+                << container.cppSignature() << "'.\n";
             writeContainerConverterFunctions(s, container);
             if (container.generateOpaqueContainer()) {
-                opaqueContainers.insert(container,
-                                        writeOpaqueContainerConverterFunctions(s, container));
+                auto data = writeOpaqueContainerConverterFunctions(s, container,
+                                                                   &valueConverters);
+                opaqueContainers.insert(container, data);
             }
         }
         s << '\n';
     }
 
-    // Implicit smart pointers conversions
-    const auto &smartPointersList = api().instantiatedSmartPointers();
-    if (!smartPointersList.isEmpty()) {
-        s << "// SmartPointers converters.\n\n";
-        for (const auto &smp : smartPointersList) {
-            s << "// C++ to Python conversion for smart pointer type '"
-                << smp.type.cppSignature() << "'.\n";
-            writeSmartPointerConverterFunctions(s, smp.type);
-        }
-        s << '\n';
-    }
-
     s << "static struct PyModuleDef moduledef = {\n"
         << "    /* m_base     */ PyModuleDef_HEAD_INIT,\n"
         << "    /* m_name     */ \"" << moduleName() << "\",\n"
@@ -6855,6 +6376,8 @@ bool CppGenerator::finishGeneration()
     // PYSIDE-510: Create a signatures string for the introspection feature.
     writeSignatureStrings(s, signatureStream.toString(), moduleName(), "global functions");
 
+    writeInitInheritance(s);
+
     // Write module init function
     const QString globalModuleVar = pythonModuleObjectName();
     s << "extern \"C\" LIBSHIBOKEN_EXPORT PyObject *PyInit_"
@@ -6864,8 +6387,8 @@ bool CppGenerator::finishGeneration()
         << indent << "return " << globalModuleVar << ";\n" << outdent;
 
     // module inject-code target/beginning
-    if (!snips.isEmpty())
-        writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::TargetLangCode);
+    writeModuleCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning,
+                         TypeSystem::TargetLangCode);
 
     for (const QString &requiredModule : requiredModules) {
         s << "{\n" << indent
@@ -6881,9 +6404,30 @@ bool CppGenerator::finishGeneration()
 
     int maxTypeIndex = getMaxTypeIndex() + api().instantiatedSmartPointers().size();
     if (maxTypeIndex) {
-        s << "// Create an array of wrapper types for the current module.\n"
-           << "static PyTypeObject *cppApi[SBK_" << moduleName() << "_IDX_COUNT];\n"
-           << cppApiVariableName() << " = cppApi;\n\n";
+        s << "// Create an array of wrapper types/names for the current module.\n"
+            << "static Shiboken::Module::TypeInitStruct cppApi[] = {\n" << indent;
+
+        // Windows did not like an array of QString.
+        QStringList typeNames;
+        for (int idx = 0; idx < maxTypeIndex; ++idx)
+            typeNames.append("+++ unknown entry #"_L1 + QString::number(idx)
+                             + " in "_L1 + moduleName());
+
+        collectFullTypeNamesArray(typeNames);
+
+        for (auto typeName : typeNames)
+            s << "{nullptr, \"" << typeName << "\"},\n";
+
+        s << "{nullptr, nullptr}\n" << outdent << "};\n"
+            << "// The new global structure consisting of (type, name) pairs.\n"
+            << cppApiVariableName() << " = cppApi;\n";
+        if (usePySideExtensions())
+            s << "QT_WARNING_PUSH\nQT_WARNING_DISABLE_DEPRECATED\n";
+        s << "// The backward compatible alias with upper case indexes.\n"
+            << cppApiVariableNameOld() << " = reinterpret_cast<PyTypeObject **>(cppApi);\n";
+        if (usePySideExtensions())
+            s << "QT_WARNING_POP\n";
+        s << '\n';
     }
 
     s << "// Create an array of primitive type converters for the current module.\n"
@@ -6893,8 +6437,13 @@ bool CppGenerator::finishGeneration()
         << "PyObject *module = Shiboken::Module::create(\""  << moduleName()
         << "\", &moduledef);\n\n"
         << "// Make module available from global scope\n"
-        << globalModuleVar << " = module;\n\n"
-        << "// Initialize classes in the type system\n"
+        << globalModuleVar << " = module;\n\n";
+
+    const QString subModuleOf = typeDb->defaultTypeSystemType()->subModuleOf();
+    if (!subModuleOf.isEmpty())
+        writeSubModuleHandling(s,  moduleName(), subModuleOf);
+
+    s << "// Initialize classes in the type system\n"
         << s_classPythonDefines.toString();
 
     if (!typeConversions.isEmpty()) {
@@ -6908,7 +6457,7 @@ bool CppGenerator::finishGeneration()
     if (!containers.isEmpty()) {
         s << '\n';
         for (const AbstractMetaType &container : containers) {
-            const QString converterObj = writeContainerConverterInitialization(s, container);
+            const QString converterObj = writeContainerConverterInitialization(s, container, api());
             const auto it = opaqueContainers.constFind(container);
             if (it !=  opaqueContainers.constEnd()) {
                 writeSetPythonToCppPointerConversion(s, converterObj,
@@ -6927,14 +6476,6 @@ bool CppGenerator::finishGeneration()
         s << '\n';
     }
 
-    if (!smartPointersList.isEmpty()) {
-        s << '\n';
-        for (const auto &smp : smartPointersList) {
-            writeSmartPointerConverterInitialization(s, smp.type);
-            s << '\n';
-        }
-    }
-
     if (!extendedConverters.isEmpty()) {
         s << '\n';
         for (ExtendedConverterData::const_iterator it = extendedConverters.cbegin(), end = extendedConverters.cend(); it != end; ++it) {
@@ -6943,7 +6484,7 @@ bool CppGenerator::finishGeneration()
         }
     }
 
-    writeEnumsInitialization(s, globalEnums, ErrorReturn::Default);
+    writeEnumsInitialization(s, globalEnums);
 
     s << "// Register primitive types converters.\n";
     const PrimitiveTypeEntryCList &primitiveTypeList = primitiveTypes();
@@ -6953,14 +6494,7 @@ bool CppGenerator::finishGeneration()
         if (!pte->referencesType())
             continue;
         TypeEntryCPtr referencedType = basicReferencedTypeEntry(pte);
-        QString converter = converterObject(referencedType);
-        QStringList cppSignature = pte->qualifiedCppName().split(u"::"_s, Qt::SkipEmptyParts);
-        while (!cppSignature.isEmpty()) {
-            QString signature = cppSignature.join(u"::"_s);
-            s << "Shiboken::Conversions::registerConverterName("
-                << converter << ", \"" << signature << "\");\n";
-            cppSignature.removeFirst();
-        }
+        registerConverterInScopes(s, pte->qualifiedCppName(), converterObject(referencedType));
     }
 
     s << '\n';
@@ -6972,27 +6506,29 @@ bool CppGenerator::finishGeneration()
     // of the previously registered types (PYSIDE-1529).
     if (!classesWithStaticFields.isEmpty()) {
         s << "\n// Static field initialization\n";
-        for (auto cls : std::as_const(classesWithStaticFields))
-            s << getSimpleClassStaticFieldsInitFunctionName(cls) << "();\n";
+        for (const auto &cls : std::as_const(classesWithStaticFields)) {
+            ConfigurableScope configScope(s, cls->typeEntry());
+            s << getSimpleClassStaticFieldsInitFunctionName(cls) << "(module);\n";
+        }
     }
 
-    s << "\nif (PyErr_Occurred()) {\n" << indent
+    s << '\n' << initInheritanceFunction << "();\n"
+        << "\nif (" << shibokenErrorsOccurred << ") {\n" << indent
         << "PyErr_Print();\n"
         << "Py_FatalError(\"can't initialize module " << moduleName() << "\");\n"
         << outdent << "}\n";
 
     // module inject-code target/end
-    if (!snips.isEmpty())
-        writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::TargetLangCode);
+    writeModuleCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::TargetLangCode);
 
     // module inject-code native/end
-    if (!snips.isEmpty())
-        writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode);
+    writeModuleCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode);
 
     if (usePySideExtensions()) {
         for (const AbstractMetaEnum &metaEnum : std::as_const(globalEnums))
             if (!metaEnum.isAnonymous()) {
-                s << "qRegisterMetaType< ::" << metaEnum.typeEntry()->qualifiedCppName()
+                ConfigurableScope configScope(s, metaEnum.typeEntry());
+                s << "qRegisterMetaType< " << getFullTypeName(metaEnum.typeEntry())
                   << " >(\"" << metaEnum.name() << "\");\n";
             }
 
@@ -7000,7 +6536,7 @@ bool CppGenerator::finishGeneration()
         s << "PySide::registerCleanupFunction(cleanTypesAttributes);\n\n";
     }
 
-    // finish the rest of __signature__ initialization.
+    // finish the rest of get_signature() initialization.
     s << "FinishSignatureInitialization(module, " << moduleName()
         << "_SignatureStrings);\n"
         << "\nreturn module;\n" << outdent << "}\n";
@@ -7026,17 +6562,17 @@ static bool useParentHeuristics(const ApiExtractorResult &api,
 {
     if (!ComplexTypeEntry::isParentManagementEnabled()) // FIXME PYSIDE 7: Remove this
         return true;
-    auto *owner = func->ownerClass();
-    if (owner == nullptr)
+    const auto owner = func->ownerClass();
+    if (!owner)
         return false;
-    auto ownerEntry = owner->parentManagementEntry();
-    if (ownerEntry.isNull())
+    auto ownerEntry = parentManagementEntry(owner);
+    if (!ownerEntry)
         return false;
     auto argTypeEntry = argType.typeEntry();
     if (!argTypeEntry->isComplex())
         return false;
-    auto *argClass = AbstractMetaClass::findClass(api.classes(), argTypeEntry);
-    return argClass != nullptr && argClass->parentManagementEntry() == ownerEntry;
+    const auto argClass = AbstractMetaClass::findClass(api.classes(), argTypeEntry);
+    return argClass && parentManagementEntry(argClass) == ownerEntry;
 }
 
 bool CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaFunctionCPtr &func,
@@ -7075,7 +6611,7 @@ bool CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaF
             if (parentIndex == 0) {
                 parentVariable = PYTHON_RETURN_VAR;
             } else if (parentIndex == -1) {
-                parentVariable = u"self"_s;
+                parentVariable = PYTHON_SELF_VAR;
             } else {
                 parentVariable = usePyArgs
                     ? pythonArgsAt(parentIndex - 1) : PYTHON_ARG;
@@ -7085,7 +6621,7 @@ bool CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaF
         if (childIndex == 0) {
             childVariable = PYTHON_RETURN_VAR;
         } else if (childIndex == -1) {
-            childVariable = u"self"_s;
+            childVariable = PYTHON_SELF_VAR;
         } else {
             childVariable = usePyArgs
                 ? pythonArgsAt(childIndex - 1) : PYTHON_ARG;
@@ -7142,9 +6678,9 @@ void CppGenerator::writeReturnValueHeuristics(TextStream &s, const AbstractMetaF
     }
 }
 
-void CppGenerator::writeHashFunction(TextStream &s, const GeneratorContext &context) const
+void CppGenerator::writeHashFunction(TextStream &s, const GeneratorContext &context)
 {
-    const AbstractMetaClass *metaClass = context.metaClass();
+    const auto metaClass = context.metaClass();
     const char hashType[] = "Py_hash_t";
     s << "static " << hashType << ' ' << cpythonBaseName(metaClass)
         << "_HashFunc(PyObject *self)\n{\n" << indent;
@@ -7168,7 +6704,7 @@ void CppGenerator::writeHashFunction(TextStream &s, const GeneratorContext &cont
 void CppGenerator::writeDefaultSequenceMethods(TextStream &s,
                                                const GeneratorContext &context) const
 {
-    const AbstractMetaClass *metaClass = context.metaClass();
+    const auto metaClass = context.metaClass();
     ErrorReturn errorReturn = ErrorReturn::Zero;
 
     // __len__
@@ -7235,14 +6771,20 @@ void CppGenerator::writeIndexError(TextStream &s, const QString &errorMsg,
         << errorReturn << outdent << "}\n";
 }
 
+QString CppGenerator::writeReprFunctionHeader(TextStream &s, const GeneratorContext &context)
+{
+    QString funcName = cpythonBaseName(context.metaClass()) + REPR_FUNCTION;
+    s << "extern \"C\"\n{\n"
+      << "static PyObject *" << funcName << "(PyObject *self)\n{\n" << indent;
+    return funcName;
+}
+
 QString CppGenerator::writeReprFunction(TextStream &s,
                                         const GeneratorContext &context,
-                                        uint indirections) const
+                                        uint indirections)
 {
-    const AbstractMetaClass *metaClass = context.metaClass();
-    QString funcName = cpythonBaseName(metaClass) + reprFunction();
-    s << "extern \"C\"\n{\n"
-        << "static PyObject *" << funcName << "(PyObject *self)\n{\n" << indent;
+    const auto metaClass = context.metaClass();
+    QString funcName = writeReprFunctionHeader(s, context);
     writeCppSelfDefinition(s, context);
     s << R"(QBuffer buffer;
 buffer.open(QBuffer::ReadWrite);
@@ -7257,15 +6799,21 @@ const auto idx = str.indexOf('(');
 auto *typeName = Py_TYPE(self)->tp_name;
 if (idx >= 0)
 )" << indent << "str.replace(0, idx, typeName);\n" << outdent
-       << "str = str.trimmed();\n"
-        << "PyObject *mod = PyDict_GetItem(Py_TYPE(self)->tp_dict, Shiboken::PyMagicName::module());\n";
+        << "str = str.trimmed();\n"
+        << "Shiboken::AutoDecRef tpDict(PepType_GetDict(Py_TYPE(self)));\n"
+        << "PyObject *mod = PyDict_GetItem(tpDict.object(), Shiboken::PyMagicName::module());\n";
     // PYSIDE-595: The introduction of heap types has the side effect that the module name
     // is always prepended to the type name. Therefore the strchr check:
     s << "if (mod != nullptr && std::strchr(typeName, '.') == nullptr)\n" << indent
         << "return Shiboken::String::fromFormat(\"<%s.%s at %p>\","
            " Shiboken::String::toCString(mod), str.constData(), self);\n"
         << outdent
-        << "return Shiboken::String::fromFormat(\"<%s at %p>\", str.constData(), self);\n"
-        << outdent << "}\n} // extern C\n\n";
+        << "return Shiboken::String::fromFormat(\"<%s at %p>\", str.constData(), self);\n";
+    writeReprFunctionFooter(s);
     return funcName;
 }
+
+void CppGenerator::writeReprFunctionFooter(TextStream &s)
+{
+    s << outdent << "}\n} // extern C\n\n";
+}
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.h b/sources/shiboken6/generator/shiboken/cppgenerator.h
index b2e99b7bb..5920c9a3a 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.h
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.h
@@ -5,13 +5,15 @@
 #define CPPGENERATOR_H
 
 #include "shibokengenerator.h"
-#include "abstractmetalang_enums.h"
 #include "include.h"
 #include "modifications_typedefs.h"
 
 #include <QtCore/QFlags>
+#include <QtCore/QSet>
 #include <QtCore/QHash>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
+#include <utility>
 
 class OverloadDataNode;
 class OverloadDataRootNode;
@@ -43,66 +45,67 @@ public:
 
 protected:
     QString fileNameForContext(const GeneratorContext &context) const override;
-    static QList<AbstractMetaFunctionCList>
-        filterGroupedOperatorFunctions(const AbstractMetaClass *metaClass,
-                                       OperatorQueryOptions query);
     void generateClass(TextStream &s, const GeneratorContext &classContext) override;
     bool finishGeneration() override;
 
 private:
-    struct BoolCastFunction
+    struct VirtualMethodReturn
     {
-        AbstractMetaFunctionCPtr function;
-        bool invert = false; // Function is isNull() (invert result).
+        QString statement;
+        bool needsReference = false;
     };
-    using BoolCastFunctionOptional = std::optional<BoolCastFunction>;
+
 
     void generateSmartPointerClass(TextStream &s, const GeneratorContext &classContext);
     void generateIncludes(TextStream &s, const GeneratorContext &classContext,
                           const IncludeGroupList &includes = {},
                           const AbstractMetaClassCList &innerClasses = {}) const;
-    static void writeInitFunc(TextStream &declStr, TextStream &callStr,
-                              const QString &initFunctionName,
-                              const TypeEntryCPtr &enclosingEntry = {});
+    static void writeInitFuncCall(TextStream &callStr,
+                                  const QString &functionName,
+                                  const TypeEntryCPtr &enclosingEntry,
+                                  const QString &pythonName, bool lazy = true);
     static void writeCacheResetNative(TextStream &s, const GeneratorContext &classContext);
     void writeConstructorNative(TextStream &s, const GeneratorContext &classContext,
                                 const AbstractMetaFunctionCPtr &func) const;
-    void writeDestructorNative(TextStream &s, const GeneratorContext &classContext) const;
+    static void writeDestructorNative(TextStream &s, const GeneratorContext &classContext);
 
     QString getVirtualFunctionReturnTypeName(const AbstractMetaFunctionCPtr &func) const;
-    static QPair<QString, QChar>
-        virtualMethodNativeArg(const AbstractMetaFunctionCPtr &func,
+    static std::pair<QString, QChar> virtualMethodNativeArg(const AbstractMetaFunctionCPtr &func,
                                const AbstractMetaArgument &arg);
-    void writeVirtualMethodNativeVectorCallArgs(TextStream &s,
-                                                const AbstractMetaFunctionCPtr &func,
-                                                const AbstractMetaArgumentList &arguments,
-                                                const QList<int> &invalidateArgs) const;
-    void writeVirtualMethodNativeArgs(TextStream &s,
-                                      const AbstractMetaFunctionCPtr &func,
-                                      const AbstractMetaArgumentList &arguments,
-                                      const QList<int> &invalidateArgs) const;
-    void writeVirtualMethodNative(TextStream &s, const AbstractMetaFunctionCPtr &func,
+    static void writeVirtualMethodNativeVectorCallArgs(TextStream &s,
+                                                       const AbstractMetaFunctionCPtr &func,
+                                                       const AbstractMetaArgumentList &arguments,
+                                                       const QList<int> &invalidateArgs);
+    static void writeVirtualMethodNativeArgs(TextStream &s,
+                                             const AbstractMetaFunctionCPtr &func,
+                                             const AbstractMetaArgumentList &arguments,
+                                             const QList<int> &invalidateArgs);
+    void writeVirtualMethodNative(TextStream &s,
+                                  const AbstractMetaFunctionCPtr &func,
                                   int cacheIndex) const;
+    void writeVirtualMethodPythonOverride(TextStream &s,
+                                          const AbstractMetaFunctionCPtr &func,
+                                          const CodeSnipList &snips,
+                                          const VirtualMethodReturn &returnStatement) const;
+    void writeUserAddedPythonOverride(TextStream &s,
+                                      const AbstractMetaFunctionCPtr &func) const;
     void writeVirtualMethodCppCall(TextStream &s, const AbstractMetaFunctionCPtr &func,
                                    const QString &funcName, const QList<CodeSnip> &snips,
                                    const AbstractMetaArgument *lastArg, const TypeEntryCPtr &retType,
                                    const QString &returnStatement, bool hasGil) const;
-    static QString virtualMethodReturn(TextStream &s, const ApiExtractorResult &api,
-                                       const AbstractMetaFunctionCPtr &func,
-                                       const FunctionModificationList &functionModifications);
+
+    static VirtualMethodReturn virtualMethodReturn(const ApiExtractorResult &api,
+                                                   const AbstractMetaFunctionCPtr &func,
+                                                   const FunctionModificationList &functionModifications);
     void writeMetaObjectMethod(TextStream &s, const GeneratorContext &classContext) const;
     static void writeMetaCast(TextStream &s, const GeneratorContext &classContext);
 
-    void writeFlagsConverterFunctions(TextStream &s, const FlagsTypeEntryCPtr &flagsType,
-                                      const QString &enumTypeName,
-                                      const QString &flagsCppTypeName,
-                                      const QString &enumTypeCheck) const;
     void writeEnumConverterFunctions(TextStream &s, const AbstractMetaEnum &metaEnum) const;
-    void writeConverterFunctions(TextStream &s, const AbstractMetaClass *metaClass,
+    void writeConverterFunctions(TextStream &s, const AbstractMetaClassCPtr &metaClass,
                                  const GeneratorContext &classContext) const;
     void writeCustomConverterFunctions(TextStream &s,
                                        const CustomConversionPtr &customConversion) const;
-    void writeConverterRegister(TextStream &s, const AbstractMetaClass *metaClass,
+    void writeConverterRegister(TextStream &s, const AbstractMetaClassCPtr &metaClass,
                                 const GeneratorContext &classContext) const;
     static void writeCustomConverterRegister(TextStream &s,
                                              const CustomConversionPtr &customConversion,
@@ -122,16 +125,21 @@ private:
 
     OpaqueContainerData
         writeOpaqueContainerConverterFunctions(TextStream &s,
-                                               const AbstractMetaType &containerType) const;
+                                               const AbstractMetaType &containerType,
+                                               QSet<AbstractMetaType> *valueTypes) const;
+    void writeOpaqueContainerValueConverter(TextStream &s,
+                                            const AbstractMetaType &valueType) const;
 
     void writeSmartPointerConverterFunctions(TextStream &s,
                                              const AbstractMetaType &smartPointerType) const;
 
-    bool needsArgumentErrorHandling(const OverloadData &overloadData) const;
-    void writeMethodWrapperPreamble(TextStream &s, const OverloadData &overloadData,
-                                    const GeneratorContext &context,
-                                    ErrorReturn errorReturn = ErrorReturn::Default) const;
-    void writeConstructorWrapper(TextStream &s, const OverloadData &overloadData,
+    static bool needsArgumentErrorHandling(const OverloadData &overloadData);
+    static void writeMethodWrapperPreamble(TextStream &s,
+                                           const OverloadData &overloadData,
+                                           const GeneratorContext &context,
+                                           ErrorReturn errorReturn = ErrorReturn::Default);
+    void writeConstructorWrapper(TextStream &s,
+                                 const OverloadData &overloadData,
                                  const GeneratorContext &classContext) const;
     void writeMethodWrapper(TextStream &s, const OverloadData &overloadData,
                             const GeneratorContext &classContext) const;
@@ -147,22 +155,29 @@ private:
                                        bool useWrapperClass);
     static void writeSmartPointerCppSelfConversion(TextStream &s,
                                                    const GeneratorContext &context);
+
+    static void writeCppSelfVarDef(TextStream &s, CppSelfDefinitionFlags flags = {});
     static void writeSmartPointerCppSelfDefinition(TextStream &s,
                                                    const GeneratorContext &,
                                                    ErrorReturn errorReturn = ErrorReturn::Default,
                                                    CppSelfDefinitionFlags flags = {});
-    void writeCppSelfDefinition(TextStream &s,
-                                const AbstractMetaFunctionCPtr &func,
-                                const GeneratorContext &context,
-                                ErrorReturn errorReturn = ErrorReturn::Default,
-                                CppSelfDefinitionFlags flags = {}) const;
-    void writeCppSelfDefinition(TextStream &s,
-                                const GeneratorContext &context,
-                                ErrorReturn errorReturn = ErrorReturn::Default,
-                                CppSelfDefinitionFlags flags = {}) const;
-
-    static void writeErrorSection(TextStream &s, const OverloadData &overloadData,
+    static void writeCppSelfDefinition(TextStream &s,
+                                       const AbstractMetaFunctionCPtr &func,
+                                       const GeneratorContext &context,
+                                       ErrorReturn errorReturn = ErrorReturn::Default,
+                                       CppSelfDefinitionFlags flags = {});
+    static void writeCppSelfDefinition(TextStream &s,
+                                       const GeneratorContext &context,
+                                       ErrorReturn errorReturn = ErrorReturn::Default,
+                                       CppSelfDefinitionFlags flags = {});
+
+    static void writeErrorSection(TextStream &s,
+                                  const OverloadData &overloadData,
                                   ErrorReturn errorReturn);
+
+    static QString returnErrorWrongArguments(const OverloadData &overloadData,
+                                             ErrorReturn errorReturn);
+
     static void writeFunctionReturnErrorCheckSection(TextStream &s,
                                                      ErrorReturn errorReturn,
                                                      bool hasReturnValue = true);
@@ -176,18 +191,22 @@ private:
                                bool isNumber = false, bool rejectNull = false);
     static void writeTypeCheck(TextStream &s, const QString &customType,
                         const QString &argumentName);
-    static void writeTypeCheck(TextStream& s, const QSharedPointer<OverloadDataNode> &overloadData,
+    static void writeTypeCheck(TextStream& s, const std::shared_ptr<OverloadDataNode> &overloadData,
                         const QString &argumentName);
 
-    static void writeTypeDiscoveryFunction(TextStream &s, const AbstractMetaClass *metaClass);
+    static void replacePolymorphicIdPlaceHolders(const AbstractMetaClassCPtr &metaClass,
+                                                 QString *id);
+    static void writeTypeDiscoveryFunction(TextStream &s,
+                                           const AbstractMetaClassCPtr &metaClass);
 
-    void writeSetattroDefinition(TextStream &s, const AbstractMetaClass *metaClass) const;
+    static void writeSetattroDefinition(TextStream &s, const AbstractMetaClassCPtr &metaClass);
     static void writeSetattroDefaultReturn(TextStream &s);
-    void writeSmartPointerSetattroFunction(TextStream &s,
-                                           const GeneratorContext &context) const;
-    void writeSetattroFunction(TextStream &s, AttroCheck attroCheck,
+    static void writeSmartPointerSetattroFunction(TextStream &s,
+                                                  const GeneratorContext &context);
+    void writeSetattroFunction(TextStream &s,
+                               AttroCheck attroCheck,
                                const GeneratorContext &context) const;
-    static void writeGetattroDefinition(TextStream &s, const AbstractMetaClass *metaClass);
+    static void writeGetattroDefinition(TextStream &s, const AbstractMetaClassCPtr &metaClass);
     static void writeSmartPointerGetattroFunction(TextStream &s,
                                                   const GeneratorContext &context,
                                                   const BoolCastFunctionOptional &boolCast);
@@ -195,11 +214,10 @@ private:
                                const GeneratorContext &context) const;
     QString qObjectGetAttroFunction() const;
 
-    void writeNbBoolFunction(const GeneratorContext &context,
-                             const BoolCastFunction &f,
-                             TextStream &s) const;
-    static void writeNbBoolExpression(TextStream &s, const BoolCastFunction &f,
-                                      bool invert = false);
+    static void writeNbBoolFunction(const GeneratorContext &context,
+                                    const BoolCastFunction &f,
+                                    TextStream &s);
+    static void writeNbBoolExpression(TextStream &s, const BoolCastFunction &f, bool invert = false);
 
     /**
      *   Writes Python to C++ conversions for arguments on Python wrappers.
@@ -216,7 +234,7 @@ private:
     qsizetype writeArgumentConversion(TextStream &s, const AbstractMetaType &argType,
                                       const QString &argName, const QString &pyArgName,
                                       ErrorReturn errorReturn,
-                                      const AbstractMetaClass *context = nullptr,
+                                      const AbstractMetaClassCPtr &context = {},
                                       const QString &defaultValue = QString(),
                                       bool castArgumentAsUnused = false) const;
 
@@ -238,7 +256,7 @@ private:
                                         const AbstractMetaType &type,
                                         const QString &pyIn,
                                         const QString &cppOut,
-                                        const AbstractMetaClass *context = nullptr,
+                                        const AbstractMetaClassCPtr &context = {},
                                         const QString &defaultValue = {}) const;
 
     /// Writes the conversion rule for arguments of regular and virtual methods.
@@ -266,7 +284,8 @@ private:
      *   \param s text stream to write
      *   \param overloadData the overload data describing all the possible overloads for the function/method
      */
-    void writeOverloadedFunctionDecisor(TextStream &s, const OverloadData &overloadData) const;
+    void writeOverloadedFunctionDecisor(TextStream &s, const OverloadData &overloadData,
+                                        ErrorReturn errorReturn) const;
     /// Recursive auxiliar method to the other writeOverloadedFunctionDecisor.
     void writeOverloadedFunctionDecisorEngine(TextStream &s,
                                               const OverloadData &overloadData,
@@ -305,6 +324,8 @@ private:
                                   QString targetTypeName = QString()) const;
     void writeCppToPythonFunction(TextStream &s, const CustomConversionPtr &customConversion) const;
     void writeCppToPythonFunction(TextStream &s, const AbstractMetaType &containerType) const;
+    /// Main target type name of a container (for naming the functions).
+    static QString containerNativeToTargetTypeName(const ContainerTypeEntryCPtr &type);
 
     /// Writes a Python to C++ conversion function.
     void writePythonToCppFunction(TextStream &s, const QString &code, const QString &sourceTypeName,
@@ -334,6 +355,10 @@ private:
     void writePythonToCppConversionFunctions(TextStream &s,
                                              const AbstractMetaType &containerType) const;
 
+    void writePythonToCppConversionFunction(TextStream &s,
+                                            const AbstractMetaType &containerType,
+                                            const TargetToNativeConversion &conv) const;
+
     static void writeAddPythonToCppConversion(TextStream &s, const QString &converterVar,
                                               const QString &pythonToCppFunc,
                                               const QString &isConvertibleFunc);
@@ -342,15 +367,18 @@ private:
                                               const QString &pythonToCppFunc,
                                               const QString &isConvertibleFunc);
 
-    void writeNamedArgumentResolution(TextStream &s, const AbstractMetaFunctionCPtr &func,
-                                      bool usePyArgs, const OverloadData &overloadData) const;
+    static void writeNamedArgumentResolution(TextStream &s,
+                                             const AbstractMetaFunctionCPtr &func,
+                                             bool usePyArgs,
+                                             const OverloadData &overloadData,
+                                             ErrorReturn errorReturn);
 
     /// Returns a string containing the name of an argument for the given function and argument index.
     static QString argumentNameFromIndex(const ApiExtractorResult &api,
                                          const AbstractMetaFunctionCPtr &func, int argIndex);
     /// Returns the class for an ownership modification of the argument.
     /// Throws if the argument is not a class or cannot be found.
-    static const AbstractMetaClass *
+    static AbstractMetaClassCPtr
         argumentClassFromIndex(const ApiExtractorResult &api,
                                const AbstractMetaFunctionCPtr &func, int argIndex);
 
@@ -360,111 +388,102 @@ private:
                          ErrorReturn errorReturn) const;
 
     static QString getInitFunctionName(const GeneratorContext &context) ;
-    static QString getSimpleClassInitFunctionName(const AbstractMetaClass *metaClass) ;
-    static QString getSimpleClassStaticFieldsInitFunctionName(const AbstractMetaClass *metaClass);
+    static QString getSimpleClassInitFunctionName(const AbstractMetaClassCPtr &metaClass);
+    static QString
+        getSimpleClassStaticFieldsInitFunctionName(const AbstractMetaClassCPtr &metaClass);
 
     static void writeSignatureStrings(TextStream &s, const QString &signatures,
                                       const QString &arrayName,
                                       const char *comment);
+    void writeInitInheritance(TextStream &s) const;
     void writeClassRegister(TextStream &s,
-                            const AbstractMetaClass *metaClass,
+                            const AbstractMetaClassCPtr &metaClass,
                             const GeneratorContext &classContext,
                             const QString &signatures) const;
-    QString destructorClassName(const AbstractMetaClass *metaClass,
-                                const GeneratorContext &classContext) const;
+    static QStringList pyBaseTypes(const AbstractMetaClassCPtr &metaClass);
+    static QString destructorClassName(const AbstractMetaClassCPtr &metaClass,
+                                       const GeneratorContext &classContext);
     static void writeStaticFieldInitialization(TextStream &s,
-                                               const AbstractMetaClass *metaClass);
+                                               const AbstractMetaClassCPtr &metaClass);
     void writeClassDefinition(TextStream &s,
-                              const AbstractMetaClass *metaClass,
+                              const AbstractMetaClassCPtr &metaClass,
                               const GeneratorContext &classContext);
     QByteArrayList methodDefinitionParameters(const OverloadData &overloadData) const;
     QList<PyMethodDefEntry> methodDefinitionEntries(const OverloadData &overloadData) const;
 
     void writeSignatureInfo(TextStream &s, const OverloadData &overloads) const;
     QString signatureParameter(const AbstractMetaArgument &arg) const;
+    QString pythonSignature(const AbstractMetaType &type) const;
     /// Writes the implementation of all methods part of python sequence protocol
     void writeSequenceMethods(TextStream &s,
-                              const AbstractMetaClass *metaClass,
+                              const AbstractMetaClassCPtr &metaClass,
                               const GeneratorContext &context) const;
     static void writeTypeAsSequenceDefinition(TextStream &s,
-                                         const AbstractMetaClass *metaClass);
+                                         const AbstractMetaClassCPtr &metaClass);
 
     /// Writes the PyMappingMethods structure for types that supports the python mapping protocol.
     static void writeTypeAsMappingDefinition(TextStream &s,
-                                        const AbstractMetaClass *metaClass);
+                                        const AbstractMetaClassCPtr &metaClass);
     void writeMappingMethods(TextStream &s,
-                             const AbstractMetaClass *metaClass,
+                             const AbstractMetaClassCPtr &metaClass,
                              const GeneratorContext &context) const;
 
-    void writeTypeAsNumberDefinition(TextStream &s, const AbstractMetaClass *metaClass) const;
-
-    static void writeTpTraverseFunction(TextStream &s, const AbstractMetaClass *metaClass);
-    static void writeTpClearFunction(TextStream &s, const AbstractMetaClass *metaClass);
-
-    void writeCopyFunction(TextStream &s, const GeneratorContext &context) const;
-
-    QString cppFieldAccess(const AbstractMetaField &metaField,
-                           const GeneratorContext &context) const;
-    void writeGetterFunction(TextStream &s,
-                             const AbstractMetaField &metaField,
-                             const GeneratorContext &context) const;
-    void writeGetterFunction(TextStream &s,
-                             const QPropertySpec &property,
-                             const GeneratorContext &context) const;
-    void writeSetterFunctionPreamble(TextStream &s,
-                                     const QString &name,
-                                     const QString &funcName,
-                                     const AbstractMetaType &type,
-                                     const GeneratorContext &context) const;
-    void writeSetterFunction(TextStream &s,
-                             const AbstractMetaField &metaField,
-                             const GeneratorContext &context) const;
-    void writeSetterFunction(TextStream &s,
-                             const QPropertySpec &property,
-                             const GeneratorContext &context) const;
-
-    void writeRichCompareFunctionHeader(TextStream &s,
-                                        const QString &baseName,
-                                        const GeneratorContext &context) const;
-    static void writeRichCompareFunctionFooter(TextStream &s,
-                                               const QString &baseName);
+    void writeTypeAsNumberDefinition(TextStream &s, const AbstractMetaClassCPtr &metaClass) const;
+
+    static void writeTpTraverseFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass);
+    static void writeTpClearFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass);
+
+    static QString writeCopyFunction(TextStream &s, TextStream &definitionStream,
+                                     TextStream &signatureStream, const GeneratorContext &context);
+
+    static QString cppFieldAccess(const AbstractMetaField &metaField,
+                                  const GeneratorContext &context);
+    static void writeGetterFunction(TextStream &s,
+                                    const AbstractMetaField &metaField,
+                                    const GeneratorContext &context);
+    static void writeGetterFunction(TextStream &s,
+                                    const QPropertySpec &property,
+                                    const GeneratorContext &context);
+    static void writeSetterFunctionPreamble(TextStream &s,
+                                            const QString &name,
+                                            const QString &funcName,
+                                            const AbstractMetaType &type,
+                                            const GeneratorContext &context);
+    static void writeSetterFunction(TextStream &s,
+                                    const AbstractMetaField &metaField,
+                                    const GeneratorContext &context);
+    static void writeSetterFunction(TextStream &s,
+                                    const QPropertySpec &property,
+                                    const GeneratorContext &context);
+
+    static void writeRichCompareFunctionHeader(TextStream &s,
+                                               const QString &baseName,
+                                               const GeneratorContext &context);
     void writeRichCompareFunction(TextStream &s, const GeneratorContext &context) const;
     void writeSmartPointerRichCompareFunction(TextStream &s, const GeneratorContext &context) const;
 
-    void writeEnumsInitialization(TextStream &s, AbstractMetaEnumList &enums,
-                                  ErrorReturn errorReturn) const;
-    void writeEnumInitialization(TextStream &s, const AbstractMetaEnum &metaEnum,
-                                 ErrorReturn errorReturn) const;
+    static void writeEnumsInitialization(TextStream &s, AbstractMetaEnumList &enums);
+    static bool writeEnumInitialization(TextStream &s, const AbstractMetaEnum &metaEnum);
 
-    static void writeSignalInitialization(TextStream &s, const AbstractMetaClass *metaClass);
-
-    static void writeFlagsMethods(TextStream &s, const AbstractMetaEnum &cppEnum);
-    static void writeFlagsToLong(TextStream &s, const AbstractMetaEnum &cppEnum);
-    static void writeFlagsNonZero(TextStream &s, const AbstractMetaEnum &cppEnum);
-    static void writeFlagsNumberMethodsDefinition(TextStream &s, const AbstractMetaEnum &cppEnum);
-    static void writeFlagsNumberMethodsDefinitions(TextStream &s,
-                                                   const AbstractMetaEnumList &enums);
-    static void writeFlagsBinaryOperator(TextStream &s,
-                                         const AbstractMetaEnum &cppEnum,
-                                         const QString &pyOpName,
-                                         const QString &cppOpName);
-    static void writeFlagsUnaryOperator(TextStream &s,
-                                        const AbstractMetaEnum &cppEnum,
-                                        const QString &pyOpName,
-                                        const QString &cppOpName,
-                                        bool boolResult = false);
-
-    /// Writes the function that registers the multiple inheritance information for the classes that need it.
-    static void writeMultipleInheritanceInitializerFunction(TextStream &s, const AbstractMetaClass *metaClass);
-    /// Writes the implementation of special cast functions, used when we need to cast a class with multiple inheritance.
-    static void writeSpecialCastFunction(TextStream &s, const AbstractMetaClass *metaClass);
+    static void writeSignalInitialization(TextStream &s, const AbstractMetaClassCPtr &metaClass);
+
+    /// Writes the function that registers the multiple inheritance information
+    /// for the classes that need it.
+    static void writeMultipleInheritanceInitializerFunction(TextStream &s,
+                                                            const AbstractMetaClassCPtr &metaClass);
+    /// Writes the implementation of special cast functions, used when we need
+    /// to cast a class with multiple inheritance.
+    static void writeSpecialCastFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass);
 
     static void writePrimitiveConverterInitialization(TextStream &s,
                                                       const CustomConversionPtr &customConversion);
-    static void writeFlagsConverterInitialization(TextStream &s, const FlagsTypeEntryCPtr &enumType);
     static void writeEnumConverterInitialization(TextStream &s, const AbstractMetaEnum &metaEnum);
-    QString writeContainerConverterInitialization(TextStream &s, const AbstractMetaType &type) const;
+    static QString writeContainerConverterInitialization(TextStream &s,
+                                                         const AbstractMetaType &type,
+                                                         const ApiExtractorResult &api);
     void writeSmartPointerConverterInitialization(TextStream &s, const AbstractMetaType &ype) const;
+
+    static QString typeInitStruct(const TypeEntryCPtr &te);
     static void writeExtendedConverterInitialization(TextStream &s,
                                                      const TypeEntryCPtr &externalType,
                                                      const AbstractMetaClassCList &conversions);
@@ -485,24 +504,25 @@ private:
      *   \return name of the multiple inheritance information initializer function or
      *           an empty string if there is no multiple inheritance in its ancestry.
      */
-    static QString multipleInheritanceInitializerFunctionName(const AbstractMetaClass *metaClass);
+    static QString multipleInheritanceInitializerFunctionName(const AbstractMetaClassCPtr &metaClass);
 
     /// Returns a list of all classes to which the given class could be cast.
-    static QStringList getAncestorMultipleInheritance(const AbstractMetaClass *metaClass);
+    static QStringList getAncestorMultipleInheritance(const AbstractMetaClassCPtr &metaClass);
 
     /// Returns true if the given class supports the python number protocol
-    bool supportsNumberProtocol(const AbstractMetaClass *metaClass) const;
+    static bool supportsNumberProtocol(const AbstractMetaClassCPtr &metaClass);
 
     /// Returns true if the given class supports the python sequence protocol
-    static bool supportsSequenceProtocol(const AbstractMetaClass *metaClass) ;
+    static bool supportsSequenceProtocol(const AbstractMetaClassCPtr &metaClass) ;
 
     /// Returns true if the given class supports the python mapping protocol
-    static bool supportsMappingProtocol(const AbstractMetaClass *metaClass) ;
+    static bool supportsMappingProtocol(const AbstractMetaClassCPtr &metaClass) ;
 
     /// Returns true if generator should produce getters and setters for the given class.
-    bool shouldGenerateGetSetList(const AbstractMetaClass *metaClass) const;
+    static bool shouldGenerateGetSetList(const AbstractMetaClassCPtr &metaClass);
 
-    void writeHashFunction(TextStream &s, const GeneratorContext &context) const;
+    static bool hasHashFunction(const AbstractMetaClassCPtr &c);
+    static void writeHashFunction(TextStream &s, const GeneratorContext &context);
 
     /// Write default implementations for sequence protocol
     void writeDefaultSequenceMethods(TextStream &s, const GeneratorContext &context) const;
@@ -510,23 +530,36 @@ private:
     static void writeIndexError(TextStream &s, const QString &errorMsg,
                                 ErrorReturn errorReturn);
 
-    QString writeReprFunction(TextStream &s, const GeneratorContext &context,
-                              uint indirections) const;
-
-    BoolCastFunctionOptional boolCast(const AbstractMetaClass *metaClass) const;
-    bool hasBoolCast(const AbstractMetaClass *metaClass) const
+    static QString writeReprFunctionHeader(TextStream &s, const GeneratorContext &context);
+    static QString writeReprFunction(TextStream &s,
+                                     const GeneratorContext &context,
+                                     uint indirections);
+    static QString writeSmartPointerReprFunction(TextStream &s,
+                                                 const GeneratorContext &context);
+    static QString writeSmartPointerDirFunction(TextStream &s,
+                                                TextStream &definitionStream,
+                                                TextStream &signatureStream,
+                                                const GeneratorContext &context);
+    static void writeReprFunctionFooter(TextStream &s);
+    static void writePyMethodDefs(TextStream &s, const QString &className,
+                                  const QString &methodsDefinitions);
+
+    void writeModuleCodeSnips(TextStream &s, const CodeSnipList &codeSnips,
+                              TypeSystem::CodeSnipPosition position,
+                              TypeSystem::Language language) const;
+
+    static bool hasBoolCast(const AbstractMetaClassCPtr &metaClass)
     { return boolCast(metaClass).has_value(); }
 
-    std::optional<AbstractMetaType>
-        findSmartPointerInstantiation(const SmartPointerTypeEntryCPtr &pointer,
-                                      const TypeEntryCPtr &pointee) const;
     void clearTpFuncs();
+    static QString chopType(QString s);
 
     QHash<QString, QString> m_tpFuncs;
-
-    static const char *PYTHON_TO_CPPCONVERSION_STRUCT;
+    QHash<QString, QString> m_nbFuncs;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(CppGenerator::CppSelfDefinitionFlags)
 
+TextStream &operator<<(TextStream &s, CppGenerator::ErrorReturn r);
+
 #endif // CPPGENERATOR_H
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp b/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp
index 38cb5b3c1..00e0cabea 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp
@@ -2,11 +2,13 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "cppgenerator.h"
+#include "generatorstrings.h"
 #include <abstractmetalang.h>
 #include "apiextractorresult.h"
 #include "ctypenames.h"
 #include "containertypeentry.h"
 #include "textstream.h"
+#include "typedatabase.h"
 
 #include <QtCore/QDebug>
 
@@ -53,23 +55,37 @@ static void writeSlot(TextStream &s, const QString &privateObjType,
 
 // Write creation function from C++ reference, used by field accessors
 // and getters which are within extern "C"
+
+enum ContainerCreationFlag
+{
+    None = 0,
+    Const = 0x1,
+    Allocate = 0x2
+};
+
+Q_DECLARE_FLAGS(ContainerCreationFlags, ContainerCreationFlag)
+Q_DECLARE_OPERATORS_FOR_FLAGS(ContainerCreationFlags)
+
 static void writeContainerCreationFunc(TextStream &s,
                                        const QString &funcName,
                                        const QString &typeFName,
                                        const QString &containerSignature,
-                                       bool isConst = false)
+                                       ContainerCreationFlags flags = {})
 {
 
     // creation function from C++ reference, used by field accessors
     // which are within extern "C"
     s << "extern \"C\" PyObject *" << funcName << '(';
-    if (isConst)
+    if (flags.testFlag(ContainerCreationFlag::Const))
         s << "const ";
     s << containerSignature << "* ct)\n{\n" << indent
         << "auto *container = PyObject_New(ShibokenContainer, " << typeFName << "());\n"
         << "auto *d = new ShibokenSequenceContainerPrivate<"
         << containerSignature << ">();\n";
-    if (isConst) {
+    if (flags.testFlag(ContainerCreationFlag::Allocate)) {
+        s << "d->m_list = new " << containerSignature << "(*ct);\n"
+            << "d->m_ownsList = true;\n";
+    } else if (flags.testFlag(ContainerCreationFlag::Const)) {
         s << "d->m_list = const_cast<" << containerSignature << " *>(ct);\n"
             << "d->m_const = true;\n";
     } else {
@@ -80,34 +96,22 @@ static void writeContainerCreationFunc(TextStream &s,
         << "}\n\n";
 }
 
-// Generate code for a type wrapping a C++ container instantiation
-CppGenerator::OpaqueContainerData
-   CppGenerator::writeOpaqueContainerConverterFunctions(TextStream &s,
-                                                        const AbstractMetaType &containerType) const
+// Generate template specialization of value converter helper
+void CppGenerator::writeOpaqueContainerValueConverter(TextStream &s,
+                                                      const AbstractMetaType &valueType) const
 {
-    OpaqueContainerData result;
-    const auto &valueType = containerType.instantiations().constFirst();
-    const auto containerTypeEntry = qSharedPointerCast<const ContainerTypeEntry>(containerType.typeEntry());
-    result.name = containerTypeEntry->opaqueContainerName(valueType.typeEntry()->name());
-
-    const auto cppSignature = containerType.cppSignature();
-    s << "\n// Binding for " << cppSignature << "\n\n";
-
     // Generate template specialization of value converter helper unless it is already there
-    const QString pyArg = u"pyArg"_s;
-    const QString cppArg = u"cppArg"_s;
-
     const QString valueTypeName = valueType.cppSignature();
     const QString checkFunction = cpythonCheckFunction(valueType);
 
     s << "template <>\nstruct ShibokenContainerValueConverter<"
       << valueTypeName << ">\n{\n";
     // Type check
-    s << indent << "static bool checkValue(PyObject *" << pyArg << ")\n{\n"
+    s << indent << "static bool checkValue(PyObject *" << PYTHON_ARG << ")\n{\n"
         << indent << "return " << checkFunction;
     if (!checkFunction.contains(u'('))
         s << '(';
-    s << pyArg << ");\n"
+    s << PYTHON_ARG << ");\n"
         << outdent << "}\n\n";
 
     // C++ to Python
@@ -119,42 +123,68 @@ CppGenerator::OpaqueContainerData
     s << valueTypeName << ' ';
     if (passByConstRef)
         s << '&';
-    s << cppArg << ")\n{\n" << indent << "return ";
-    writeToPythonConversion(s, valueType, nullptr, cppArg);
+    s << CPP_ARG << ")\n{\n" << indent << "return ";
+    writeToPythonConversion(s, valueType, nullptr, CPP_ARG);
     s << ";\n" << outdent << "}\n\n";
 
     // Python to C++
     s << "static std::optional<" << valueTypeName << "> convertValueToCpp(PyObject *"
-        << pyArg << ")\n{\n" << indent;
+        << PYTHON_ARG << ")\n{\n" << indent;
     s << PYTHON_TO_CPPCONVERSION_STRUCT << ' ' << PYTHON_TO_CPP_VAR << ";\n"
         << "if (!(";
-    writeTypeCheck(s, valueType, pyArg), isNumber(valueType.typeEntry());
+    writeTypeCheck(s, valueType, PYTHON_ARG), isNumber(valueType.typeEntry());
     s << ")) {\n" << indent
         << "Shiboken::Errors::setWrongContainerType();\n"
         << "return {};\n" << outdent << "}\n";
-        writePythonToCppTypeConversion(s, valueType, pyArg, cppArg, nullptr, {});
-    s << "return " << cppArg << ";\n" << outdent << "}\n" << outdent << "};\n\n";
+    writePythonToCppTypeConversion(s, valueType, PYTHON_ARG, CPP_ARG, nullptr, {});
+    s << "return " << CPP_ARG << ";\n" << outdent << "}\n" << outdent << "};\n\n";
+}
+
+// Generate code for a type wrapping a C++ container instantiation
+CppGenerator::OpaqueContainerData
+   CppGenerator::writeOpaqueContainerConverterFunctions(TextStream &s,
+                                                        const AbstractMetaType &containerType,
+                                                        QSet<AbstractMetaType> *valueTypes) const
+{
+    OpaqueContainerData result;
+    const auto &valueType = containerType.instantiations().constFirst();
+    const auto containerTypeEntry = std::static_pointer_cast<const ContainerTypeEntry>(containerType.typeEntry());
+    result.name =
+        containerTypeEntry->opaqueContainerName(containerType.instantiationCppSignatures());
+
+    const auto cppSignature = containerType.cppSignature();
+    s << "\n// Binding for " << cppSignature << "\n\n";
+
+    if (!valueTypes->contains(valueType)) {
+        valueTypes->insert(valueType);
+        writeOpaqueContainerValueConverter(s, valueType);
+    }
 
     const QString privateObjType = u"ShibokenSequenceContainerPrivate<"_s
         + cppSignature + u'>';
 
     // methods
-    const bool isStdVector = containerType.name() == u"std::vector";
+    const QString &containerName = containerType.name();
+    const bool isStdVector = containerName  == u"std::vector";
+    const auto kind = containerTypeEntry->containerKind();
+    const bool isFixed = kind == ContainerTypeEntry::SpanContainer || containerName == u"std::array";
     const QString methods = result.name + u"_methods"_s;
     s << "static PyMethodDef " << methods << "[] = {\n" << indent;
-    writeMethod(s, privateObjType, "push_back");
-    writeMethod(s, privateObjType, "push_back", "append"); // Qt convention
-    writeNoArgsMethod(s, privateObjType, "clear");
-    writeNoArgsMethod(s, privateObjType, "pop_back");
-    writeNoArgsMethod(s, privateObjType, "pop_back", "removeLast"); // Qt convention
-    if (!isStdVector) {
-        writeMethod(s, privateObjType, "push_front");
-        writeMethod(s, privateObjType, "push_front", "prepend"); // Qt convention
-        writeNoArgsMethod(s, privateObjType, "pop_front");
-        writeMethod(s, privateObjType, "pop_front", "removeFirst"); // Qt convention
+    if (!isFixed) {
+        writeMethod(s, privateObjType, "push_back");
+        writeMethod(s, privateObjType, "push_back", "append"); // Qt convention
+        writeNoArgsMethod(s, privateObjType, "clear");
+        writeNoArgsMethod(s, privateObjType, "pop_back");
+        writeNoArgsMethod(s, privateObjType, "pop_back", "removeLast"); // Qt convention
+        if (!isStdVector) {
+            writeMethod(s, privateObjType, "push_front");
+            writeMethod(s, privateObjType, "push_front", "prepend"); // Qt convention
+            writeNoArgsMethod(s, privateObjType, "pop_front");
+            writeMethod(s, privateObjType, "pop_front", "removeFirst"); // Qt convention
+        }
+        writeMethod(s, privateObjType, "reserve"); // SFINAE'd out for list
+        writeNoArgsMethod(s, privateObjType, "capacity");
     }
-    writeMethod(s, privateObjType, "reserve");
-    writeNoArgsMethod(s, privateObjType, "capacity");
     writeNoArgsMethod(s, privateObjType, "data");
     writeNoArgsMethod(s, privateObjType, "constData");
     s << "{nullptr, nullptr, 0, nullptr} // Sentinel\n"
@@ -164,7 +194,8 @@ CppGenerator::OpaqueContainerData
     const QString slotsList = result.name + u"_slots"_s;
     s << "static PyType_Slot " << slotsList << "[] = {\n" << indent;
     writeSlot(s, privateObjType, "Py_tp_init", "tpInit");
-    writeSlot(s, privateObjType, "Py_tp_new", "tpNew");
+    const auto *tpNew = containerTypeEntry->viewOn() == nullptr ? "tpNew" : "tpNewInvalid";
+    writeSlot(s, privateObjType, "Py_tp_new", tpNew);
     writeSlot(s, privateObjType, "Py_tp_free", "tpFree");
     writeSlot(s, "Py_tp_dealloc", "Sbk_object_dealloc"); // FIXME?
     writeSlot(s, "Py_tp_methods", methods.toUtf8().constData());
@@ -175,7 +206,8 @@ CppGenerator::OpaqueContainerData
 
     // spec
     const QString specName = result.name + u"_spec"_s;
-    const QString name = moduleName() + u'.' + result.name;
+    const QString name = TypeDatabase::instance()->defaultPackageName()
+        + u'.' + result.name;
     s << "static PyType_Spec " << specName << " = {\n" << indent
         << "\"" << name.count(u'.') << ':' << name << "\",\n"
         << "sizeof(ShibokenContainer),\n0,\nPy_TPFLAGS_DEFAULT,\n"
@@ -186,7 +218,8 @@ CppGenerator::OpaqueContainerData
     s << "static inline PyTypeObject *" << typeCreationFName << "()\n{\n" << indent
         << "auto *result = reinterpret_cast<PyTypeObject *>(SbkType_FromSpec(&"
         << specName <<  "));\nPy_INCREF(Py_True);\n"
-        << "PyDict_SetItem(result->tp_dict, "
+        << "Shiboken::AutoDecRef tpDict(PepType_GetDict(result));\n"
+        << "PyDict_SetItem(tpDict.object(), "
            "Shiboken::PyMagicName::opaque_container(), Py_True);\n"
         << "return result;\n" << outdent << "}\n\n";
 
@@ -197,32 +230,37 @@ CppGenerator::OpaqueContainerData
         << "();\nreturn type;\n" << outdent << "}\n\n";
 
     // creation functions from C++ references
+    ContainerCreationFlags flags;
+    if (kind == ContainerTypeEntry::SpanContainer)
+        flags.setFlag(ContainerCreationFlag::Allocate);
+
     writeContainerCreationFunc(s, u"create"_s + result.name, typeFName,
-                               containerType.cppSignature());
+                               containerType.cppSignature(), flags);
+    flags.setFlag(ContainerCreationFlag::Const);
     writeContainerCreationFunc(s, u"createConst"_s + result.name, typeFName,
-                               containerType.cppSignature(), true);
+                               containerType.cppSignature(), flags);
 
     // Check function
     result.checkFunctionName = result.name + u"_Check"_s;
-    s << "extern \"C\" int " << result.checkFunctionName << "(PyObject *" << pyArg
-        << ")\n{\n" << indent << "return " << pyArg << " != nullptr && "
-        << pyArg << " != Py_None && " << pyArg << "->ob_type == "
+    s << "extern \"C\" int " << result.checkFunctionName << "(PyObject *" << PYTHON_ARG
+        << ")\n{\n" << indent << "return " << PYTHON_ARG << " != nullptr && "
+        << PYTHON_ARG << " != Py_None && " << PYTHON_ARG << "->ob_type == "
         << typeFName << "();\n" << outdent << "}\n\n";
 
     // SBK converter Python to C++
     result.pythonToConverterFunctionName = u"PythonToCpp"_s + result.name;
     s << "extern \"C\" void " << result.pythonToConverterFunctionName
-        << "(PyObject *" << pyArg << ", void *cppOut)\n{\n" << indent
+        << "(PyObject *" << PYTHON_ARG << ", void *cppOut)\n{\n" << indent
         << "auto *d = ShibokenSequenceContainerPrivate<" << cppSignature
-        << ">::get(" << pyArg << ");\n"
+        << ">::get(" << PYTHON_ARG << ");\n"
         << "*reinterpret_cast<" << cppSignature << "**>(cppOut) = d->m_list;\n"
         << outdent << "}\n\n";
 
     // SBK check function for converting Python to C++ that returns the converter
     result.converterCheckFunctionName = u"is"_s + result.name + u"PythonToCppConvertible"_s;
     s << "extern \"C\" PythonToCppFunc " << result.converterCheckFunctionName
-        << "(PyObject *" << pyArg << ")\n{\n" << indent << "if ("
-        << result.checkFunctionName << '(' << pyArg << "))\n" << indent
+        << "(PyObject *" << PYTHON_ARG << ")\n{\n" << indent << "if ("
+        << result.checkFunctionName << '(' << PYTHON_ARG << "))\n" << indent
         << "return " << result.pythonToConverterFunctionName << ";\n"
         << outdent << "return {};\n" << outdent << "}\n\n";
 
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator_smartpointer.cpp b/sources/shiboken6/generator/shiboken/cppgenerator_smartpointer.cpp
new file mode 100644
index 000000000..44b76f181
--- /dev/null
+++ b/sources/shiboken6/generator/shiboken/cppgenerator_smartpointer.cpp
@@ -0,0 +1,476 @@
+// 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 "cppgenerator.h"
+#include "generatorstrings.h"
+#include "generatorcontext.h"
+#include <apiextractorresult.h>
+#include <abstractmetafunction.h>
+#include <abstractmetalang.h>
+#include <codesnip.h>
+#include <exception.h>
+#include <messages.h>
+#include <textstream.h>
+#include <overloaddata.h>
+#include <smartpointertypeentry.h>
+
+#include <QtCore/QDebug>
+
+using namespace Qt::StringLiterals;
+
+static const char smartPtrComment[] =
+    "// Try to find the 'name' attribute, by retrieving the PyObject for "
+    "the corresponding C++ object held by the smart pointer.\n";
+
+static QString smartPointerGetter(const GeneratorContext &context)
+{
+    const auto te = context.metaClass()->typeEntry();
+    Q_ASSERT(te->isSmartPointer());
+    return std::static_pointer_cast<const SmartPointerTypeEntry>(te)->getter();
+}
+
+struct callGetter
+{
+    explicit callGetter(const GeneratorContext &context) : m_context(context) {}
+
+    const GeneratorContext &m_context;
+};
+
+TextStream &operator<<(TextStream &str, const callGetter &c)
+{
+    str << "PyObject_CallMethod(self, \"" << smartPointerGetter(c.m_context) << "\", 0)";
+    return str;
+}
+
+// Helpers to collect all smart pointer pointee base classes
+static AbstractMetaClassCList
+    findSmartPointeeBaseClasses(const ApiExtractorResult &api,
+                            const AbstractMetaType &smartPointerType)
+{
+    AbstractMetaClassCList result;
+    auto instantiationsTe = smartPointerType.instantiations().at(0).typeEntry();
+    auto targetClass = AbstractMetaClass::findClass(api.classes(), instantiationsTe);
+    if (targetClass != nullptr)
+        result = targetClass->allTypeSystemAncestors();
+    return result;
+}
+
+using ComparisonOperatorList = QList<AbstractMetaFunction::ComparisonOperatorType>;
+
+// Return the available comparison operators for smart pointers
+static ComparisonOperatorList smartPointeeComparisons(const GeneratorContext &context)
+{
+    Q_ASSERT(context.forSmartPointer());
+    auto te = context.preciseType().instantiations().constFirst().typeEntry();
+    if (isExtendedCppPrimitive(te)) { // Primitive pointee types have all
+        return {AbstractMetaFunction::OperatorEqual,
+                AbstractMetaFunction::OperatorNotEqual,
+                AbstractMetaFunction::OperatorLess,
+                AbstractMetaFunction::OperatorLessEqual,
+                AbstractMetaFunction::OperatorGreater,
+                AbstractMetaFunction::OperatorGreaterEqual};
+    }
+
+    const auto pointeeClass = context.pointeeClass();
+    if (!pointeeClass)
+        return {};
+
+    ComparisonOperatorList result;
+    const auto &comparisons =
+        pointeeClass->operatorOverloads(OperatorQueryOption::SymmetricalComparisonOp);
+    for (const auto &f : comparisons) {
+        const auto ct = f->comparisonOperatorType().value();
+        if (!result.contains(ct))
+            result.append(ct);
+    }
+    return result;
+}
+
+static bool hasParameterPredicate(const AbstractMetaFunctionCPtr &f)
+{
+    return !f->arguments().isEmpty();
+}
+
+void CppGenerator::generateSmartPointerClass(TextStream &s, const GeneratorContext &classContext)
+{
+    s.setLanguage(TextStream::Language::Cpp);
+    AbstractMetaClassCPtr metaClass = classContext.metaClass();
+    const auto typeEntry = std::static_pointer_cast<const SmartPointerTypeEntry>(metaClass->typeEntry());
+    const bool hasPointeeClass = classContext.pointeeClass() != nullptr;
+    const auto smartPointerType = typeEntry->smartPointerType();
+    const bool isValueHandle = smartPointerType ==TypeSystem::SmartPointerType::ValueHandle;
+
+    IncludeGroup includes{u"Extra includes"_s, typeEntry->extraIncludes()};
+    if (hasPointeeClass)
+        includes.append(classContext.pointeeClass()->typeEntry()->include());
+    includes.includes.append({Include::IncludePath, u"sbksmartpointer.h"_s});
+    generateIncludes(s, classContext, {includes});
+
+    s << '\n';
+
+    // class inject-code native/beginning
+    if (!typeEntry->codeSnips().isEmpty()) {
+        writeClassCodeSnips(s, typeEntry->codeSnips(),
+                            TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode,
+                            classContext);
+        s << '\n';
+    }
+
+    StringStream smd(TextStream::Language::Cpp);
+    StringStream md(TextStream::Language::Cpp);
+    StringStream signatureStream(TextStream::Language::Cpp);
+
+    s << openTargetExternC;
+
+    const auto &functionGroups = getFunctionGroups(metaClass);
+
+    // Skip all public methods of the smart pointer except for the special
+    // methods declared in the type entry.
+
+    auto ctors = metaClass->queryFunctions(FunctionQueryOption::Constructors);
+    if (!hasPointeeClass && !isValueHandle) { // Cannot generate "int*"
+        auto end = std::remove_if(ctors.begin(), ctors.end(), hasParameterPredicate);
+        ctors.erase(end, ctors.end());
+    }
+
+    if (!ctors.isEmpty()) {
+        OverloadData overloadData(ctors, api());
+        writeConstructorWrapper(s, overloadData, classContext);
+        writeSignatureInfo(signatureStream, overloadData);
+    }
+
+    if (!typeEntry->resetMethod().isEmpty()) {
+        auto it = functionGroups.constFind(typeEntry->resetMethod());
+        if (it == functionGroups.cend())
+            throw Exception(msgCannotFindSmartPointerMethod(typeEntry, typeEntry->resetMethod()));
+        AbstractMetaFunctionCList resets = it.value();
+        if (!hasPointeeClass && !isValueHandle) { // Cannot generate "int*"
+            auto end = std::remove_if(resets.begin(), resets.end(), hasParameterPredicate);
+            resets.erase(end, resets.end());
+        }
+        if (!resets.isEmpty())
+            writeMethodWrapper(s, md, signatureStream, resets, classContext);
+    }
+
+    auto it = functionGroups.constFind(typeEntry->getter());
+    if (it == functionGroups.cend() || it.value().size() != 1)
+        throw Exception(msgCannotFindSmartPointerGetter(typeEntry));
+
+    writeMethodWrapper(s, md, signatureStream, it.value(), classContext);
+
+    QStringList optionalMethods;
+    if (!typeEntry->refCountMethodName().isEmpty())
+        optionalMethods.append(typeEntry->refCountMethodName());
+    const QString valueCheckMethod = typeEntry->valueCheckMethod();
+    if (!valueCheckMethod.isEmpty() && !valueCheckMethod.startsWith(u"operator"))
+        optionalMethods.append(valueCheckMethod);
+    if (!typeEntry->nullCheckMethod().isEmpty())
+        optionalMethods.append(typeEntry->nullCheckMethod());
+
+    for (const QString &optionalMethod : optionalMethods) {
+        auto it = functionGroups.constFind(optionalMethod);
+        if (it == functionGroups.cend() || it.value().size() != 1)
+            throw Exception(msgCannotFindSmartPointerMethod(typeEntry, optionalMethod));
+        writeMethodWrapper(s, md, signatureStream, it.value(), classContext);
+    }
+
+    writeCopyFunction(s, md, signatureStream, classContext);
+    writeSmartPointerDirFunction(s, md, signatureStream, classContext);
+
+    const QString methodsDefinitions = md.toString();
+    const QString singleMethodDefinitions = smd.toString();
+
+    const QString className = chopType(cpythonTypeName(typeEntry));
+
+    // Write single method definitions
+    s << singleMethodDefinitions;
+
+    // Write methods definition
+    writePyMethodDefs(s, className, methodsDefinitions);
+
+    // Write tp_s/getattro function
+    const auto boolCastOpt = boolCast(metaClass);
+    writeSmartPointerGetattroFunction(s, classContext, boolCastOpt);
+    writeSmartPointerSetattroFunction(s, classContext);
+
+    if (boolCastOpt.has_value())
+        writeNbBoolFunction(classContext, boolCastOpt.value(), s);
+
+    if (smartPointerType == TypeSystem::SmartPointerType::Shared)
+        writeSmartPointerRichCompareFunction(s, classContext);
+
+    s << closeExternC;
+
+    if (hasHashFunction(metaClass))
+        writeHashFunction(s, classContext);
+
+    // Write tp_traverse and tp_clear functions.
+    writeTpTraverseFunction(s, metaClass);
+    writeTpClearFunction(s, metaClass);
+
+    writeClassDefinition(s, metaClass, classContext);
+
+    s << '\n';
+
+    writeConverterFunctions(s, metaClass, classContext);
+    // Implicit smart pointers conversions
+    writeSmartPointerConverterFunctions(s, classContext.preciseType());
+    writeClassRegister(s, metaClass, classContext, signatureStream);
+
+    // class inject-code native/end
+    if (!typeEntry->codeSnips().isEmpty()) {
+        writeClassCodeSnips(s, typeEntry->codeSnips(),
+                            TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode,
+                            classContext);
+        s << '\n';
+    }
+}
+
+void CppGenerator::writeSmartPointerConverterFunctions(TextStream &s,
+                                                       const AbstractMetaType &smartPointerType) const
+{
+    const auto baseClasses = findSmartPointeeBaseClasses(api(), smartPointerType);
+    if (baseClasses.isEmpty())
+        return;
+
+    auto smartPointerTypeEntry =
+        std::static_pointer_cast<const SmartPointerTypeEntry>(smartPointerType.typeEntry());
+
+    // TODO: Missing conversion to smart pointer pointer type:
+
+    s << "// Register smartpointer conversion for all derived classes\n";
+    for (const auto &base : baseClasses) {
+        auto baseTe = base->typeEntry();
+        if (smartPointerTypeEntry->matchesInstantiation(baseTe)) {
+            if (auto opt = api().findSmartPointerInstantiation(smartPointerTypeEntry, baseTe)) {
+                const auto &smartTargetType = opt.value().type;
+                s << "// SmartPointer derived class: "
+                  << smartTargetType.cppSignature() << "\n";
+                writePythonToCppConversionFunctions(s, smartPointerType,
+                                                    smartTargetType, {}, {}, {});
+            }
+        }
+    }
+}
+
+void CppGenerator::writeSmartPointerCppSelfConversion(TextStream &s,
+                                                      const GeneratorContext &context)
+{
+    Q_ASSERT(context.forSmartPointer());
+    s << cpythonWrapperCPtr(context.preciseType(), u"self"_s);
+}
+
+void CppGenerator::writeSmartPointerCppSelfDefinition(TextStream &s,
+                                                      const GeneratorContext &context,
+                                                      ErrorReturn errorReturn,
+                                                      CppSelfDefinitionFlags flags)
+{
+    Q_ASSERT(context.forSmartPointer());
+    writeInvalidPyObjectCheck(s, u"self"_s, errorReturn);
+    writeCppSelfVarDef(s, flags);
+    writeSmartPointerCppSelfConversion(s, context);
+    s << ";\n";
+}
+
+void CppGenerator::writeSmartPointerConverterInitialization(TextStream &s,
+                                                            const AbstractMetaType &type) const
+{
+    const QByteArray cppSignature = type.cppSignature().toUtf8();
+    auto writeConversionRegister = [&s](const AbstractMetaType &sourceType,
+                                        const QString &targetTypeName,
+                                        const QString &targetConverter)
+    {
+        const QString sourceTypeName = fixedCppTypeName(sourceType);
+        const QString toCpp = pythonToCppFunctionName(sourceTypeName, targetTypeName);
+        const QString isConv = convertibleToCppFunctionName(sourceTypeName, targetTypeName);
+
+        writeAddPythonToCppConversion(s, targetConverter, toCpp, isConv);
+    };
+
+    const auto classes = findSmartPointeeBaseClasses(api(), type);
+    if (classes.isEmpty())
+        return;
+
+    auto smartPointerTypeEntry = std::static_pointer_cast<const SmartPointerTypeEntry>(type.typeEntry());
+
+    s << "// Register SmartPointer converter for type '" << cppSignature << "'." << '\n'
+      << "///////////////////////////////////////////////////////////////////////////////////////\n\n";
+
+    for (const auto &base : classes) {
+        auto baseTe = base->typeEntry();
+        if (auto opt = api().findSmartPointerInstantiation(smartPointerTypeEntry, baseTe)) {
+            const auto &smartTargetType = opt.value().type;
+            s << "// Convert to SmartPointer derived class: ["
+              << smartTargetType.cppSignature() << "]\n";
+            const QString converter = u"Shiboken::Conversions::getConverter(\""_s
+                                      + smartTargetType.cppSignature() + u"\")"_s;
+            writeConversionRegister(type, fixedCppTypeName(smartTargetType), converter);
+        } else {
+            s << "// Class not found:" << type.instantiations().at(0).cppSignature();
+        }
+    }
+
+    s << "///////////////////////////////////////////////////////////////////////////////////////" << '\n' << '\n';
+}
+
+void CppGenerator::writeSmartPointerRichCompareFunction(TextStream &s,
+                                                        const GeneratorContext &context) const
+{
+    static const char selfPointeeVar[] = "cppSelfPointee";
+    static const char cppArg0PointeeVar[] = "cppArg0Pointee";
+
+    const auto metaClass = context.metaClass();
+    QString baseName = cpythonBaseName(metaClass);
+    writeRichCompareFunctionHeader(s, baseName, context);
+
+    s << "if (";
+    writeTypeCheck(s, context.preciseType(), PYTHON_ARG);
+    s << ") {\n" << indent;
+    writeArgumentConversion(s, context.preciseType(), CPP_ARG0,
+                            PYTHON_ARG, ErrorReturn::Default, metaClass);
+
+    const auto te = context.preciseType().typeEntry();
+    Q_ASSERT(te->isSmartPointer());
+    const auto ste = std::static_pointer_cast<const SmartPointerTypeEntry>(te);
+
+    s << "const auto *" << selfPointeeVar << " = " << CPP_SELF_VAR
+      << '.' << ste->getter() << "();\n";
+    s << "const auto *" << cppArg0PointeeVar << " = " << CPP_ARG0
+      << '.' << ste->getter() << "();\n";
+
+    // If we have an object without any comparisons, only generate a simple
+    // equality check by pointee address
+    auto availableOps = smartPointeeComparisons(context);
+    const bool comparePointeeAddressOnly = availableOps.isEmpty();
+    if (comparePointeeAddressOnly) {
+        availableOps << AbstractMetaFunction::OperatorEqual
+                     << AbstractMetaFunction::OperatorNotEqual;
+    } else {
+        // For value types with operators, we complain about nullptr
+        s << "if (" << selfPointeeVar << " == nullptr || " << cppArg0PointeeVar
+          << " == nullptr) {\n" << indent
+          << "PyErr_SetString(PyExc_NotImplementedError, \"nullptr passed to comparison.\");\n"
+          << ErrorReturn::Default << '\n' << outdent << "}\n";
+    }
+
+    s << "bool " << CPP_RETURN_VAR << "= false;\n"
+      << "switch (op) {\n";
+    for (auto op : availableOps) {
+        s << "case " << AbstractMetaFunction::pythonRichCompareOpCode(op) << ":\n"
+          << indent << CPP_RETURN_VAR << " = ";
+        if (comparePointeeAddressOnly) {
+            s << selfPointeeVar << ' ' << AbstractMetaFunction::cppComparisonOperator(op)
+              << ' ' << cppArg0PointeeVar << ";\n";
+        } else {
+            // Shortcut for equality: Check pointee address
+            if (op == AbstractMetaFunction::OperatorEqual
+                || op == AbstractMetaFunction::OperatorLessEqual
+                || op == AbstractMetaFunction::OperatorGreaterEqual) {
+                s << selfPointeeVar << " == " << cppArg0PointeeVar << " || ";
+            }
+            // Generate object's comparison
+            s << "*" << selfPointeeVar << ' '
+              << AbstractMetaFunction::cppComparisonOperator(op) << " *"
+              << cppArg0PointeeVar << ";\n";
+        }
+        s << "break;\n" << outdent;
+
+    }
+    if (availableOps.size() < 6) {
+        s << "default:\n" << indent
+          << richCompareComment
+          << "return FallbackRichCompare(self, " << PYTHON_ARG << ", op);\n" << outdent;
+    }
+    s << "}\n" << PYTHON_RETURN_VAR << " = " << CPP_RETURN_VAR
+      << " ? Py_True : Py_False;\n"
+      << "Py_INCREF(" << PYTHON_RETURN_VAR << ");\n"
+      << outdent << "}\n"
+      << "return Shiboken::returnFromRichCompare(" << PYTHON_RETURN_VAR << ");\n"
+      << outdent << "}\n\n";
+}
+
+void CppGenerator::writeSmartPointerSetattroFunction(TextStream &s,
+                                                     const GeneratorContext &context)
+{
+    Q_ASSERT(context.forSmartPointer());
+    writeSetattroDefinition(s, context.metaClass());
+    s << smartPtrComment
+      << "if (auto *rawObj = " << callGetter(context) << ") {\n" << indent
+      << "if (PyObject_HasAttr(rawObj, name) != 0)\n" << indent
+      << "return PyObject_GenericSetAttr(rawObj, name, value);\n" << outdent
+      << "Py_DECREF(rawObj);\n" << outdent
+      << "}\n";
+    writeSetattroDefaultReturn(s);
+}
+
+void CppGenerator::writeSmartPointerGetattroFunction(TextStream &s,
+                                                     const GeneratorContext &context,
+                                                     const BoolCastFunctionOptional &boolCast)
+{
+    Q_ASSERT(context.forSmartPointer());
+    const auto metaClass = context.metaClass();
+    writeGetattroDefinition(s, metaClass);
+    s << "PyObject *tmp = PyObject_GenericGetAttr(self, name);\n"
+      << "if (tmp)\n" << indent << "return tmp;\n" << outdent
+      << "if (PyErr_ExceptionMatches(PyExc_AttributeError) == 0)\n"
+      << indent << "return nullptr;\n" << outdent
+      << "PyErr_Clear();\n";
+
+    if (boolCast.has_value()) {
+        writeSmartPointerCppSelfDefinition(s, context);
+        s << "if (";
+        writeNbBoolExpression(s, boolCast.value(), true /* invert */);
+        s << ") {\n" << indent
+          << R"(PyTypeObject *tp = Py_TYPE(self);
+PyErr_Format(PyExc_AttributeError, "Attempt to retrieve '%s' from null object '%s'.",
+             Shiboken::String::toCString(name), tp->tp_name);
+return nullptr;
+)" << outdent << "}\n";
+    }
+
+    // This generates the code which dispatches access to member functions
+    // and fields from the smart pointer to its pointee.
+    s << smartPtrComment
+      << "if (auto *rawObj = " << callGetter(context) << ") {\n" << indent
+      << "if (auto *attribute = PyObject_GetAttr(rawObj, name))\n"
+      << indent << "tmp = attribute;\n" << outdent
+      << "Py_DECREF(rawObj);\n" << outdent
+      << "}\n"
+      << "if (!tmp) {\n" << indent
+      << R"(PyTypeObject *tp = Py_TYPE(self);
+PyErr_Format(PyExc_AttributeError,
+             "'%.50s' object has no attribute '%.400s'",
+             tp->tp_name, Shiboken::String::toCString(name));
+)" << outdent
+      << "}\n"
+      << "return tmp;\n" << outdent << "}\n\n";
+}
+
+QString CppGenerator::writeSmartPointerReprFunction(TextStream &s,
+                                                    const GeneratorContext &context)
+{
+    const auto metaClass = context.metaClass();
+    QString funcName = writeReprFunctionHeader(s, context);
+    s << "Shiboken::AutoDecRef pointee(" << callGetter(context) << ");\n"
+        << "return Shiboken::SmartPointer::repr(self, pointee);\n";
+    writeReprFunctionFooter(s);
+    return funcName;
+}
+
+QString CppGenerator::writeSmartPointerDirFunction(TextStream &s, TextStream &definitionStream,
+                                                   TextStream &signatureStream,
+                                                   const GeneratorContext &context)
+{
+    QString funcName = cpythonBaseName(context.metaClass()) + u"__dir__"_s;
+
+    signatureStream << fullPythonClassName(context.metaClass()) << ".__dir__()\n";
+    definitionStream << PyMethodDefEntry{u"__dir__"_s, funcName, {"METH_NOARGS"_ba}, {}}
+        << ",\n";
+
+    s << "extern \"C\"\n{\n"
+      << "static PyObject *" << funcName << "(PyObject *self)\n{\n" << indent
+      << "Shiboken::AutoDecRef pointee(" << callGetter(context) << ");\n"
+      << "return Shiboken::SmartPointer::dir(self, pointee);\n"
+      << outdent << "}\n} // extern C\n\n";
+    return funcName;
+}
diff --git a/sources/shiboken6/generator/shiboken/ctypenames.h b/sources/shiboken6/generator/shiboken/ctypenames.h
index 0444c99f2..f665b30ff 100644
--- a/sources/shiboken6/generator/shiboken/ctypenames.h
+++ b/sources/shiboken6/generator/shiboken/ctypenames.h
@@ -6,26 +6,26 @@
 
 #include <QtCore/QString>
 
-static inline QString boolT() { return QStringLiteral("bool"); }
-static inline QString intT() { return QStringLiteral("int"); }
-static inline QString unsignedT() { return QStringLiteral("unsigned"); }
-static inline QString unsignedIntT() { return QStringLiteral("unsigned int"); }
-static inline QString longT() { return QStringLiteral("long"); }
-static inline QString unsignedLongT() { return QStringLiteral("unsigned long"); }
-static inline QString shortT() { return QStringLiteral("short"); }
-static inline QString unsignedShortT() { return QStringLiteral("unsigned short"); }
-static inline QString unsignedCharT() { return QStringLiteral("unsigned char"); }
-static inline QString longLongT() { return QStringLiteral("long long"); }
-static inline QString unsignedLongLongT() { return QStringLiteral("unsigned long long"); }
-static inline QString charT() { return QStringLiteral("char"); }
-static inline QString floatT() { return QStringLiteral("float"); }
-static inline QString doubleT() { return QStringLiteral("double"); }
-static inline QString constCharPtrT() { return QStringLiteral("const char*"); }
+constexpr auto boolT = QLatin1StringView("bool");
+constexpr auto intT = QLatin1StringView("int");
+constexpr auto unsignedT = QLatin1StringView("unsigned");
+constexpr auto unsignedIntT = QLatin1StringView("unsigned int");
+constexpr auto longT = QLatin1StringView("long");
+constexpr auto unsignedLongT = QLatin1StringView("unsigned long");
+constexpr auto shortT = QLatin1StringView("short");
+constexpr auto unsignedShortT = QLatin1StringView("unsigned short");
+constexpr auto unsignedCharT = QLatin1StringView("unsigned char");
+constexpr auto longLongT = QLatin1StringView("long long");
+constexpr auto unsignedLongLongT = QLatin1StringView("unsigned long long");
+constexpr auto charT = QLatin1StringView("char");
+constexpr auto floatT = QLatin1StringView("float");
+constexpr auto doubleT = QLatin1StringView("double");
+constexpr auto constCharPtrT = QLatin1StringView("const char*");
 
-static inline QString qByteArrayT() { return QStringLiteral("QByteArray"); }
-static inline QString qMetaObjectT() { return QStringLiteral("QMetaObject"); }
-static inline QString qObjectT() { return QStringLiteral("QObject"); }
-static inline QString qStringT() { return QStringLiteral("QString"); }
-static inline QString qVariantT() { return QStringLiteral("QVariant"); }
+constexpr auto qByteArrayT = QLatin1StringView("QByteArray");
+constexpr auto qMetaObjectT = QLatin1StringView("QMetaObject");
+constexpr auto qObjectT = QLatin1StringView("QObject");
+constexpr auto qStringT = QLatin1StringView("QString");
+constexpr auto qVariantT = QLatin1StringView("QVariant");
 
 #endif // CTYPENAMES_H
diff --git a/sources/shiboken6/generator/shiboken/generatorstrings.h b/sources/shiboken6/generator/shiboken/generatorstrings.h
new file mode 100644
index 000000000..9ce91e599
--- /dev/null
+++ b/sources/shiboken6/generator/shiboken/generatorstrings.h
@@ -0,0 +1,39 @@
+// 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 GENERATORSTRINGS_H
+#define GENERATORSTRINGS_H
+
+#include <QtCore/QString>
+
+QString CPP_ARG_N(int i);
+QString CPP_ARG_REMOVED(int i);
+
+constexpr auto CPP_RETURN_VAR = QLatin1StringView("cppResult");
+constexpr auto CPP_SELF_VAR = QLatin1StringView("cppSelf");
+constexpr auto CPP_ARG = QLatin1StringView("cppArg");
+constexpr auto NULL_PTR = QLatin1StringView("nullptr");
+constexpr auto PYTHON_ARG = QLatin1StringView("pyArg");
+constexpr auto PYTHON_ARGS = QLatin1StringView("pyArgs");
+constexpr auto PYTHON_OVERRIDE_VAR = QLatin1StringView("pyOverride");
+constexpr auto PYTHON_RETURN_VAR = QLatin1StringView("pyResult");
+constexpr auto PYTHON_SELF_VAR = QLatin1StringView("self");
+constexpr auto PYTHON_TO_CPP_VAR = QLatin1StringView("pythonToCpp");
+
+constexpr auto CONV_RULE_OUT_VAR_SUFFIX = QLatin1StringView("_out");
+constexpr auto BEGIN_ALLOW_THREADS
+    = QLatin1StringView("PyThreadState *_save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS");
+constexpr auto END_ALLOW_THREADS
+    = QLatin1StringView("PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS");
+
+constexpr auto REPR_FUNCTION = QLatin1StringView("__repr__");
+
+constexpr auto CPP_ARG0 = QLatin1StringView("cppArg0");
+
+extern const char *const METHOD_DEF_SENTINEL;
+extern const char *const PYTHON_TO_CPPCONVERSION_STRUCT;
+extern const char *const openTargetExternC;
+extern const char *const closeExternC;
+extern const char *const richCompareComment;
+
+#endif // GENERATORSTRINGS_H
diff --git a/sources/shiboken6/generator/shiboken/headergenerator.cpp b/sources/shiboken6/generator/shiboken/headergenerator.cpp
index d8e745f3e..7cec9c38e 100644
--- a/sources/shiboken6/generator/shiboken/headergenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/headergenerator.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "headergenerator.h"
+#include "configurablescope.h"
 #include "generatorcontext.h"
 #include <apiextractorresult.h>
 #include <abstractmetaargument.h>
@@ -12,6 +13,7 @@
 #include <abstractmetalang_helpers.h>
 #include <codesnip.h>
 #include <clangparser/compilersupport.h>
+#include <exception.h>
 #include <typedatabase.h>
 #include <reporthandler.h>
 #include <textstream.h>
@@ -19,6 +21,7 @@
 #include "containertypeentry.h"
 #include "enumtypeentry.h"
 #include "flagstypeentry.h"
+#include <messages.h>
 #include "namespacetypeentry.h"
 #include "primitivetypeentry.h"
 #include "typedefentry.h"
@@ -36,6 +39,22 @@
 
 using namespace Qt::StringLiterals;
 
+struct IndexValue
+{
+    QString name; // "SBK_..."
+    int value;
+    QString comment;
+};
+
+TextStream &operator<<(TextStream &s, const IndexValue &iv)
+{
+    s << "    " << AlignedField(iv.name, 56) << " = " << iv.value << ',';
+    if (!iv.comment.isEmpty())
+        s << " // " << iv.comment;
+    s << '\n';
+    return s;
+}
+
 //  PYSIDE-504: Handling the "protected hack"
 //  The problem: Creating wrappers when the class has private destructors.
 //  You can see an example on Windows in qclipboard_wrapper.h and others.
@@ -62,23 +81,26 @@ static bool alwaysGenerateDestructorDeclaration()
     return  clang::compiler() == Compiler::Msvc;
 }
 
-QString HeaderGenerator::headerFileNameForContext(const GeneratorContext &context)
-{
-    return fileNameForContextHelper(context, u"_wrapper.h"_s);
-}
+const char *HeaderGenerator::protectedHackDefine = R"(// Workaround to access protected functions
+#ifndef protected
+#  define protected public
+#endif
+
+)";
 
 QString HeaderGenerator::fileNameForContext(const GeneratorContext &context) const
 {
     return headerFileNameForContext(context);
 }
 
-void HeaderGenerator::writeCopyCtor(TextStream &s, const AbstractMetaClass *metaClass) const
+void HeaderGenerator::writeCopyCtor(TextStream &s,
+                                    const AbstractMetaClassCPtr &metaClass)
 {
     s << wrapperName(metaClass) << "(const " << metaClass->qualifiedCppName()
       << "& self) : " << metaClass->qualifiedCppName() << "(self)\n{\n}\n\n";
 }
 
-static void writeProtectedEnums(TextStream &s, const AbstractMetaClass *metaClass)
+static void writeProtectedEnums(TextStream &s, const AbstractMetaClassCPtr &metaClass)
 {
     const QString name = metaClass->qualifiedCppName();
     for (const auto &e : metaClass->enums()) {
@@ -87,134 +109,178 @@ static void writeProtectedEnums(TextStream &s, const AbstractMetaClass *metaClas
     }
 }
 
-void HeaderGenerator::generateClass(TextStream &s, const GeneratorContext &classContextIn)
+void HeaderGenerator::generateClass(TextStream &s, const GeneratorContext &classContext)
 {
-    GeneratorContext classContext = classContextIn;
-    const AbstractMetaClass *metaClass = classContext.metaClass();
-    m_inheritedOverloads.clear();
+    const AbstractMetaClassCPtr metaClass = classContext.metaClass();
 
     // write license comment
     s << licenseComment();
 
     QString wrapperName = classContext.effectiveClassName();
-    QString outerHeaderGuard = getFilteredCppSignatureString(wrapperName).toUpper();
-    QString innerHeaderGuard;
+    QString outerHeaderGuard = getFilteredCppSignatureString(wrapperName);
 
     // Header
     s << "#ifndef SBK_" << outerHeaderGuard << "_H\n";
     s << "#define SBK_" << outerHeaderGuard << "_H\n\n";
 
     if (!avoidProtectedHack())
-        s << "#define protected public\n\n";
+        s << protectedHackDefine;
 
-    //Includes
-    auto typeEntry = metaClass->typeEntry();
-    s << typeEntry->include() << '\n';
+    // Includes
+    s << metaClass->typeEntry()->include() << '\n';
     for (auto &inst : metaClass->templateBaseClassInstantiations())
         s << inst.typeEntry()->include();
 
-    if (classContext.useWrapper() && avoidProtectedHack()) {
-         const auto includeGroups = classIncludes(metaClass);
-         for( const auto &includeGroup : includeGroups)
-             s << includeGroup;
+    if (classContext.useWrapper())
+        writeWrapperClass(s, wrapperName, classContext);
+
+    s << "#endif // SBK_" << outerHeaderGuard << "_H\n\n";
+}
+
+void HeaderGenerator::writeWrapperClass(TextStream &s,
+                                        const QString &wrapperName,
+                                        const GeneratorContext &classContext) const
+{
+    const auto metaClass = classContext.metaClass();
+
+    if (avoidProtectedHack()) {
+        const auto includeGroups = classIncludes(metaClass);
+        for( const auto &includeGroup : includeGroups)
+            s << includeGroup;
     }
 
-    if (classContext.useWrapper() && usePySideExtensions() && metaClass->isQObject())
+    if (usePySideExtensions() && isQObject(metaClass))
         s << "namespace PySide { class DynamicQMetaObject; }\n\n";
 
-    while (classContext.useWrapper()) {
-        if (!innerHeaderGuard.isEmpty()) {
-            s << "#  ifndef SBK_" << innerHeaderGuard << "_H\n";
-            s << "#  define SBK_" << innerHeaderGuard << "_H\n\n";
-            s << "// Inherited base class:\n";
+    writeWrapperClassDeclaration(s, wrapperName, classContext);
+
+    // PYSIDE-500: Use also includes for inherited wrapper classes other
+    // modules, because without the protected hack, we sometimes need to
+    // cast inherited wrappers. CppGenerator generates include statements for
+    // the classes of the current module. For other modules, we insert the
+    // declarations as recursive headers, since wrapper headers are not
+    // installed. This keeps the file structure as simple as before the
+    // enhanced inheritance.
+    if (avoidProtectedHack()) {
+        const auto &baseClasses = allBaseClasses(classContext.metaClass());
+        for (const auto &baseClass : baseClasses) {
+            const auto gen = baseClass->typeEntry()->codeGeneration();
+            if (gen == TypeEntry::GenerateForSubclass) { // other module
+                const auto baseContext = contextForClass(baseClass);
+                if (baseContext.useWrapper())
+                    writeInheritedWrapperClassDeclaration(s, baseContext);
+            }
         }
+    }
+}
 
-        // Class
-        s << "class " << wrapperName
-           << " : public " << metaClass->qualifiedCppName()
-           << "\n{\npublic:\n" << indent;
-
-        // Make protected enums accessible
-        if (avoidProtectedHack()) {
-            recurseClassHierarchy(metaClass, [&s] (const AbstractMetaClass *metaClass) {
-                writeProtectedEnums(s, metaClass);
-                return false;
-            });
-        }
+void HeaderGenerator::writeInheritedWrapperClassDeclaration(TextStream &s,
+                                                            const GeneratorContext &classContext) const
+{
+    const QString wrapperName = classContext.effectiveClassName();
+    const QString innerHeaderGuard =
+        getFilteredCppSignatureString(wrapperName).toUpper();
 
-        if (avoidProtectedHack() && metaClass->hasProtectedFields()) {
-            s << "\n// Make protected fields accessible\n";
-            const QString name = metaClass->qualifiedCppName();
-            for (const auto &f : metaClass->fields()) {
-                if (f.isProtected())
-                    s << "using " << name << "::" << f.originalName() << ";\n";
-            }
-            s << '\n';
-        }
+    s << "#  ifndef SBK_" << innerHeaderGuard << "_H\n"
+      << "#  define SBK_" << innerHeaderGuard << "_H\n\n"
+      << "// Inherited base class:\n";
 
-        int maxOverrides = 0;
-        for (const auto &func : metaClass->functions()) {
-            const auto generation = functionGeneration(func);
-            writeFunction(s, func, generation);
-            // PYSIDE-803: Build a boolean cache for unused overrides.
-            if (generation.testFlag(FunctionGenerationFlag::VirtualMethod))
-                maxOverrides++;
-        }
-        if (!maxOverrides)
-            maxOverrides = 1;
-
-        //destructor
-        // PYSIDE-504: When C++ 11 is used, then the destructor must always be declared.
-        if (!avoidProtectedHack() || !metaClass->hasPrivateDestructor()
-            || alwaysGenerateDestructorDeclaration()) {
-            if (avoidProtectedHack() && metaClass->hasPrivateDestructor())
-                s << "// C++11: need to declare (unimplemented) destructor because "
-                     "the base class destructor is private.\n";
-            s << '~' << wrapperName << "();\n";
-        }
+    writeWrapperClassDeclaration(s, wrapperName, classContext);
 
-        writeClassCodeSnips(s, typeEntry->codeSnips(),
-                            TypeSystem::CodeSnipPositionDeclaration, TypeSystem::NativeCode,
-                            classContext);
+    s << "#  endif // SBK_" << innerHeaderGuard << "_H\n\n";
+}
 
-        if ((!avoidProtectedHack() || !metaClass->hasPrivateDestructor())
-            && usePySideExtensions() && metaClass->isQObject()) {
-            s << outdent << "public:\n" << indent <<
-R"(int qt_metacall(QMetaObject::Call call, int id, void **args) override;
+void HeaderGenerator::writeWrapperClassDeclaration(TextStream &s,
+                                                   const QString &wrapperName,
+                                                   const GeneratorContext &classContext) const
+{
+    const AbstractMetaClassCPtr metaClass = classContext.metaClass();
+    const auto typeEntry = metaClass->typeEntry();
+    InheritedOverloadSet inheritedOverloads;
+
+    // Class
+    s << "class " << wrapperName
+      << " : public " << metaClass->qualifiedCppName()
+      << "\n{\npublic:\n" << indent
+      << wrapperName << "(const " << wrapperName << " &) = delete;\n"
+      << wrapperName << "& operator=(const " << wrapperName << " &) = delete;\n"
+      << wrapperName << '(' << wrapperName << " &&) = delete;\n"
+      << wrapperName << "& operator=(" << wrapperName << " &&) = delete;\n\n";
+
+    // Make protected enums accessible
+    if (avoidProtectedHack()) {
+        recurseClassHierarchy(metaClass, [&s] (const AbstractMetaClassCPtr &metaClass) {
+            writeProtectedEnums(s, metaClass);
+            return false;
+        });
+    }
+
+    if (avoidProtectedHack() && metaClass->hasProtectedFields()) {
+        s << "\n// Make protected fields accessible\n";
+        const QString name = metaClass->qualifiedCppName();
+        for (const auto &f : metaClass->fields()) {
+            if (f.isProtected())
+                s << "using " << name << "::"  << f.originalName() << ";\n";
+        }
+        s << '\n';
+    }
+
+    int maxOverrides = 0;
+    for (const auto &func : metaClass->functions()) {
+        const auto generation = functionGeneration(func);
+        writeFunction(s, func, &inheritedOverloads, generation);
+        // PYSIDE-803: Build a boolean cache for unused overrides.
+        if (generation.testFlag(FunctionGenerationFlag::VirtualMethod))
+            maxOverrides++;
+    }
+    if (!maxOverrides)
+        maxOverrides = 1;
+
+    //destructor
+    // PYSIDE-504: When C++ 11 is used, then the destructor must always be declared.
+    if (!avoidProtectedHack() || !metaClass->hasPrivateDestructor()
+        || alwaysGenerateDestructorDeclaration()) {
+        if (avoidProtectedHack() && metaClass->hasPrivateDestructor())
+            s << "// C++11: need to declare (unimplemented) destructor because "
+                 "the base class destructor is private.\n";
+        s << '~' << wrapperName << "()";
+        if (metaClass->hasVirtualDestructor())
+            s << " override";
+        s << ";\n";
+    }
+
+    writeClassCodeSnips(s, typeEntry->codeSnips(),
+                        TypeSystem::CodeSnipPositionDeclaration, TypeSystem::NativeCode,
+                        classContext);
+
+    if (shouldGenerateMetaObjectFunctions(metaClass)) {
+        s << R"(
+const ::QMetaObject * metaObject() const override;
+int qt_metacall(QMetaObject::Call call, int id, void **args) override;
 void *qt_metacast(const char *_clname) override;
 )";
-        }
+    }
 
-        if (!m_inheritedOverloads.isEmpty()) {
-            s << "// Inherited overloads, because the using keyword sux\n";
-            for (const auto &func : std::as_const(m_inheritedOverloads))
-                writeMemberFunctionWrapper(s, func);
-            m_inheritedOverloads.clear();
-        }
+    if (!inheritedOverloads.isEmpty()) {
+        s << "// Inherited overloads, because the using keyword sux\n";
+        for (const auto &func : std::as_const(inheritedOverloads))
+            writeMemberFunctionWrapper(s, func);
+    }
 
-        if (usePySideExtensions())
-            s << "static void pysideInitQtMetaTypes();\n";
+    if (usePySideExtensions())
+        s << "static void pysideInitQtMetaTypes();\n";
 
-        s << "void resetPyMethodCache();\n"
-            << outdent << "private:\n" << indent
-            << "mutable bool m_PyMethodCache[" << maxOverrides << "];\n"
-            << outdent << "};\n\n";
-        if (!innerHeaderGuard.isEmpty())
-            s << "#  endif // SBK_" << innerHeaderGuard << "_H\n\n";
+    s << "void resetPyMethodCache();\n"
+        << outdent << "private:\n" << indent;
 
-        // PYSIDE-500: Use also includes for inherited wrapper classes, because
-        // without the protected hack, we sometimes need to cast inherited wrappers.
-        // But we don't use multiple include files. Instead, they are inserted as recursive
-        // headers. This keeps the file structure as simple as before the enhanced inheritance.
-        metaClass = metaClass->baseClass();
-        if (!metaClass || !avoidProtectedHack())
-            break;
-        classContext = contextForClass(metaClass);
-        wrapperName =  classContext.effectiveClassName();
-        innerHeaderGuard = getFilteredCppSignatureString(wrapperName).toUpper();
+    if (!metaClass->userAddedPythonOverrides().isEmpty()) {
+        for (const auto &f : metaClass->userAddedPythonOverrides())
+            s << functionSignature(f, {}, {}, Generator::OriginalTypeDescription) << ";\n";
+        s << '\n';
     }
 
-    s << "#endif // SBK_" << outerHeaderGuard << "_H\n\n";
+    s << "mutable bool m_PyMethodCache[" << maxOverrides << "];\n"
+      << outdent << "};\n\n";
 }
 
 // Write an inline wrapper around a function
@@ -224,8 +290,6 @@ void HeaderGenerator::writeMemberFunctionWrapper(TextStream &s,
 {
     Q_ASSERT(!func->isConstructor() && !func->isOperatorOverload());
     s << "inline ";
-    if (func->isStatic())
-        s << "static ";
     s << functionSignature(func, {}, postfix, Generator::OriginalTypeDescription)
       << " { ";
     if (!func->isVoid())
@@ -248,10 +312,10 @@ void HeaderGenerator::writeMemberFunctionWrapper(TextStream &s,
         const auto &type = arg.type();
         TypeEntryCPtr enumTypeEntry;
         if (type.isFlags())
-            enumTypeEntry = qSharedPointerCast<const FlagsTypeEntry>(type.typeEntry())->originator();
+            enumTypeEntry = std::static_pointer_cast<const FlagsTypeEntry>(type.typeEntry())->originator();
         else if (type.isEnum())
             enumTypeEntry = type.typeEntry();
-        if (!enumTypeEntry.isNull()) {
+        if (enumTypeEntry) {
             s << type.cppSignature() << '(' << arg.name() << ')';
         } else if (type.passByValue() && type.isUniquePointer()) {
             s << stdMove(arg.name());
@@ -263,7 +327,8 @@ void HeaderGenerator::writeMemberFunctionWrapper(TextStream &s,
 }
 
 void HeaderGenerator::writeFunction(TextStream &s, const AbstractMetaFunctionCPtr &func,
-                                    FunctionGeneration generation)
+                                    InheritedOverloadSet *inheritedOverloads,
+                                    FunctionGeneration generation) const
 {
 
     // do not write copy ctors here.
@@ -283,7 +348,7 @@ void HeaderGenerator::writeFunction(TextStream &s, const AbstractMetaFunctionCPt
     }
 
     const bool isVirtual = generation.testFlag(FunctionGenerationFlag::VirtualMethod);
-    if (isVirtual || generation.testFlag(FunctionGenerationFlag::QMetaObjectMethod)) {
+    if (isVirtual) {
         s << functionSignature(func, {}, {}, Generator::OriginalTypeDescription)
             << " override;\n";
     }
@@ -298,7 +363,7 @@ void HeaderGenerator::writeFunction(TextStream &s, const AbstractMetaFunctionCPt
                 && !f->isAbstract()
                 && !f->isStatic()
                 && f->name() == func->name()) {
-                m_inheritedOverloads << f;
+                inheritedOverloads->insert(f);
             }
         }
 
@@ -308,28 +373,14 @@ void HeaderGenerator::writeFunction(TextStream &s, const AbstractMetaFunctionCPt
     }
 }
 
-static void _writeTypeIndexValue(TextStream &s, const QString &variableName,
-                                 int typeIndex)
-{
-    s << "    " << AlignedField(variableName, 56) << " = " << typeIndex;
-}
-
-static inline void _writeTypeIndexValueLine(TextStream &s,
-                                            const QString &variableName,
-                                            int typeIndex)
-{
-    _writeTypeIndexValue(s, variableName, typeIndex);
-    s << ",\n";
-}
-
 // Find equivalent typedefs "using Foo=QList<int>", "using Bar=QList<int>"
-static const AbstractMetaClass *
+static AbstractMetaClassCPtr
     findEquivalentTemplateTypedef(const AbstractMetaClassCList &haystack,
-                                  const AbstractMetaClass *needle)
+                                  const AbstractMetaClassCPtr &needle)
 {
-    auto *templateBaseClass = needle->templateBaseClass();
+    auto templateBaseClass = needle->templateBaseClass();
     const auto &instantiations = needle->templateBaseClassInstantiations();
-    for (auto *candidate : haystack) {
+    for (const auto &candidate : haystack) {
         if (candidate->isTypeDef()
             && candidate->templateBaseClass() == templateBaseClass
             && candidate->templateBaseClassInstantiations() == instantiations) {
@@ -339,19 +390,20 @@ static const AbstractMetaClass *
     return nullptr;
 }
 
-void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const ApiExtractorResult &api,
-                                              const TypeEntryCPtr &typeEntry)
+void HeaderGenerator::collectTypeEntryTypeIndexes(const ApiExtractorResult &api,
+                                                  const TypeEntryCPtr &typeEntry,
+                                                  IndexValues *indexValues)
 {
     if (!typeEntry || !typeEntry->generateCode())
         return;
-    s.setFieldAlignment(QTextStream::AlignLeft);
     const int typeIndex = typeEntry->sbkIndex();
-    _writeTypeIndexValueLine(s, getTypeIndexVariableName(typeEntry), typeIndex);
+    indexValues->append({getTypeIndexVariableName(typeEntry), typeIndex, {}});
+
     if (typeEntry->isComplex()) {
         // For a typedef "using Foo=QList<int>", write a type index
         // SBK_QLIST_INT besides SBK_FOO which is then matched by function
         // argument. Check against duplicate typedefs for the same types.
-        const auto cType = qSharedPointerCast<const ComplexTypeEntry>(typeEntry);
+        const auto cType = std::static_pointer_cast<const ComplexTypeEntry>(typeEntry);
         if (cType->baseContainerType()) {
             auto metaClass = AbstractMetaClass::findClass(api.classes(), cType);
             Q_ASSERT(metaClass != nullptr);
@@ -361,20 +413,21 @@ void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const ApiExtractorR
                                                  metaClass) == nullptr) {
                 const QString indexVariable =
                     getTypeAlternateTemplateIndexVariableName(metaClass);
-                _writeTypeIndexValueLine(s, indexVariable, typeIndex);
+                indexValues->append({indexVariable, typeIndex, {}});
                 m_alternateTemplateIndexes.append(m_alternateTemplateIndexes);
             }
         }
     }
     if (typeEntry->isEnum()) {
-        auto ete = qSharedPointerCast<const EnumTypeEntry>(typeEntry);
+        auto ete = std::static_pointer_cast<const EnumTypeEntry>(typeEntry);
         if (ete->flags())
-            writeTypeIndexValueLine(s, api, ete->flags());
+            collectTypeEntryTypeIndexes(api, ete->flags(), indexValues);
     }
 }
 
-void HeaderGenerator::writeTypeIndexValueLines(TextStream &s, const ApiExtractorResult &api,
-                                               const AbstractMetaClass *metaClass)
+void HeaderGenerator::collectClassTypeIndexes(const ApiExtractorResult &api,
+                                              const AbstractMetaClassCPtr &metaClass,
+                                              IndexValues *indexValues)
 {
     auto typeEntry = metaClass->typeEntry();
     if (!typeEntry->generateCode())
@@ -382,10 +435,10 @@ void HeaderGenerator::writeTypeIndexValueLines(TextStream &s, const ApiExtractor
     // enum indices are required for invisible namespaces as well.
     for (const AbstractMetaEnum &metaEnum : metaClass->enums()) {
         if (!metaEnum.isPrivate())
-            writeTypeIndexValueLine(s, api, metaEnum.typeEntry());
+            collectTypeEntryTypeIndexes(api, metaEnum.typeEntry(), indexValues);
     }
     if (NamespaceTypeEntry::isVisibleScope(typeEntry))
-        writeTypeIndexValueLine(s, api, typeEntry);
+        collectTypeEntryTypeIndexes(api, typeEntry, indexValues);
 }
 
 // Format the typedefs for the typedef entries to be generated
@@ -417,18 +470,18 @@ static void formatTypeDefEntries(TextStream &s)
 // Helpers for forward-declaring classes in the module header for the
 // specialization of the SbkType template functions. This is possible if the
 // class does not have inner types or enums which need to be known.
-static bool canForwardDeclare(const AbstractMetaClass *c)
+static bool canForwardDeclare(const AbstractMetaClassCPtr &c)
 {
     if (c->isNamespace() || !c->enums().isEmpty()
         || !c->innerClasses().isEmpty() || c->isTypeDef()) {
         return false;
     }
-    if (auto *encl = c->enclosingClass())
+    if (auto encl = c->enclosingClass())
         return encl->isNamespace();
     return true;
 }
 
-static void writeForwardDeclaration(TextStream &s, const AbstractMetaClass *c)
+static void writeForwardDeclaration(TextStream &s, const AbstractMetaClassCPtr &c)
 {
     Q_ASSERT(!c->isNamespace());
     const bool isStruct = c->attributes().testFlag(AbstractMetaClass::Struct);
@@ -447,7 +500,7 @@ static void writeForwardDeclaration(TextStream &s, const AbstractMetaClass *c)
 // forward declarations to the module header. Ensure inline namespaces
 // are marked as such (else clang complains) and namespaces are ordered.
 struct NameSpace {
-    const AbstractMetaClass *nameSpace;
+    AbstractMetaClassCPtr nameSpace;
     AbstractMetaClassCList classes;
 };
 
@@ -458,7 +511,7 @@ static bool operator<(const NameSpace &n1, const NameSpace &n2)
 
 using NameSpaces = QList<NameSpace>;
 
-static qsizetype indexOf(const NameSpaces &nsps, const AbstractMetaClass *needle)
+static qsizetype indexOf(const NameSpaces &nsps, const AbstractMetaClassCPtr &needle)
 {
     for (qsizetype i = 0, count = nsps.size(); i < count; ++i) {
         if (nsps.at(i).nameSpace == needle)
@@ -475,7 +528,7 @@ static void writeNamespaceForwardDeclarationRecursion(TextStream &s, qsizetype i
     if (root.nameSpace->isInlineNamespace())
         s << "inline ";
     s << "namespace " << root.nameSpace->name() << " {\n" << indent;
-    for (auto *c : root.classes)
+    for (const auto &c : root.classes)
         writeForwardDeclaration(s, c);
 
     for (qsizetype i = 0, count = nameSpaces.size(); i < count; ++i) {
@@ -490,15 +543,20 @@ static void writeForwardDeclarations(TextStream &s,
 {
     NameSpaces nameSpaces;
 
-    for (auto *c : classList) {
-        if (auto *encl = c->enclosingClass()) {
+    s << '\n';
+    auto typeSystemEntry = TypeDatabase::instance()->defaultTypeSystemType();
+    if (!typeSystemEntry->namespaceBegin().isEmpty())
+        s << typeSystemEntry->namespaceBegin() << '\n';
+
+    for (const auto &c : classList) {
+        if (auto encl = c->enclosingClass()) {
             Q_ASSERT(encl->isNamespace());
             auto idx = indexOf(nameSpaces, encl);
             if (idx != -1) {
                 nameSpaces[idx].classes.append(c);
             } else {
                 nameSpaces.append(NameSpace{encl, {c}});
-                for (auto *enclNsp = encl->enclosingClass(); enclNsp != nullptr;
+                for (auto enclNsp = encl->enclosingClass(); enclNsp;
                      enclNsp = enclNsp->enclosingClass()) {
                     idx = indexOf(nameSpaces, enclNsp);
                     if (idx == -1)
@@ -518,103 +576,156 @@ static void writeForwardDeclarations(TextStream &s,
         if (nsp.nameSpace->enclosingClass() == nullptr)
             writeNamespaceForwardDeclarationRecursion(s, i, nameSpaces);
     }
+
+    if (!typeSystemEntry->namespaceEnd().isEmpty())
+        s << typeSystemEntry->namespaceEnd() << '\n';
 }
 
 // Include parameters required for the module/private module header
+
+using ConditionalIncludeMap = QMap<QString, IncludeGroup>;
+
+static TextStream &operator<<(TextStream &s, const ConditionalIncludeMap &m)
+{
+    for (auto it = m.cbegin(), end = m.cend(); it != end; ++it)
+        s << it.key() << '\n' << it.value() << "#endif\n";
+    return s;
+}
+
 struct ModuleHeaderParameters
 {
     AbstractMetaClassCList forwardDeclarations;
     std::set<Include> includes;
+    ConditionalIncludeMap conditionalIncludes;
     QString typeFunctions;
 };
 
-bool HeaderGenerator::finishGeneration()
+HeaderGenerator::IndexValues
+    HeaderGenerator::collectTypeIndexes(const AbstractMetaClassCList &classList)
 {
-    // Generate the main header for this module. This header should be included
-    // by binding modules extending on top of this one.
-    ModuleHeaderParameters parameters;
-    ModuleHeaderParameters privateParameters;
-    StringStream macrosStream(TextStream::Language::Cpp);
+    IndexValues result;
 
-    const auto snips = TypeDatabase::instance()->defaultTypeSystemType()->codeSnips();
-    if (!snips.isEmpty()) {
-        writeCodeSnips(macrosStream, snips, TypeSystem::CodeSnipPositionDeclaration,
-                       TypeSystem::TargetLangCode);
-    }
-
-    macrosStream << "// Type indices\nenum : int {\n";
-    auto classList = api().classes();
-
-    std::sort(classList.begin(), classList.end(),
-              [](const AbstractMetaClass *a, const AbstractMetaClass *b) {
-                  return a->typeEntry()->sbkIndex() < b->typeEntry()->sbkIndex();
-              });
-
-    for (const AbstractMetaClass *metaClass : classList)
-        writeTypeIndexValueLines(macrosStream, api(), metaClass);
+    for (const auto &metaClass : classList)
+        collectClassTypeIndexes(api(), metaClass, &result);
 
     for (const AbstractMetaEnum &metaEnum : api().globalEnums())
-        writeTypeIndexValueLine(macrosStream, api(), metaEnum.typeEntry());
+        collectTypeEntryTypeIndexes(api(), metaEnum.typeEntry(), &result);
 
     // Write the smart pointer define indexes.
     int smartPointerCountIndex = getMaxTypeIndex();
     int smartPointerCount = 0;
     for (const auto &smp : api().instantiatedSmartPointers()) {
         QString indexName = getTypeIndexVariableName(smp.type);
-        _writeTypeIndexValue(macrosStream, indexName, smartPointerCountIndex);
-        macrosStream << ", // " << smp.type.cppSignature() << '\n';
+        result.append({indexName, smartPointerCountIndex, smp.type.cppSignature()});
         // Add a the same value for const pointees (shared_ptr<const Foo>).
         const auto ptrName = smp.type.typeEntry()->entryName();
-        int pos = indexName.indexOf(ptrName, 0, Qt::CaseInsensitive);
+        const auto pos = indexName.indexOf(ptrName, 0, Qt::CaseInsensitive);
         if (pos >= 0) {
-            indexName.insert(pos + ptrName.size() + 1, u"CONST"_s);
-            _writeTypeIndexValue(macrosStream, indexName, smartPointerCountIndex);
-            macrosStream << ", //   (const)\n";
+            indexName.insert(pos + ptrName.size() + 1, u"const"_s);
+            result.append({indexName, smartPointerCountIndex, "(const)"_L1});
         }
         ++smartPointerCountIndex;
         ++smartPointerCount;
     }
+    result.append({"SBK_"_L1 + moduleName() + "_IDX_COUNT"_L1,
+                  getMaxTypeIndex() + smartPointerCount, {}});
+    return result;
+}
 
-    _writeTypeIndexValue(macrosStream,
-                         u"SBK_"_s + moduleName() + u"_IDX_COUNT"_s,
-                         getMaxTypeIndex() + smartPointerCount);
-    macrosStream << "\n};\n";
-
-    macrosStream << "// This variable stores all Python types exported by this module.\n";
-    macrosStream << "extern PyTypeObject **" << cppApiVariableName() << ";\n\n";
-    macrosStream << "// This variable stores the Python module object exported by this module.\n";
-    macrosStream << "extern PyObject *" << pythonModuleObjectName() << ";\n\n";
-    macrosStream << "// This variable stores all type converters exported by this module.\n";
-    macrosStream << "extern SbkConverter **" << convertersVariableName() << ";\n\n";
-
-    // TODO-CONVERTER ------------------------------------------------------------------------------
-    // Using a counter would not do, a fix must be made to APIExtractor's getTypeIndex().
-    macrosStream << "// Converter indices\nenum : int {\n";
+HeaderGenerator::IndexValues HeaderGenerator::collectConverterIndexes() const
+{
+    IndexValues result;
     const auto &primitives = primitiveTypes();
     int pCount = 0;
     for (const auto &ptype : primitives) {
-        /* Note: do not generate indices for typedef'd primitive types
-         * as they'll use the primitive type converters instead, so we
-         * don't need to create any other.
-         */
-        if (!ptype->generateCode() || !ptype->customConversion())
-            continue;
-
-        _writeTypeIndexValueLine(macrosStream, getTypeIndexVariableName(ptype), pCount++);
+        // Note: do not generate indices for typedef'd primitive types as
+        // they'll use the primitive type converters instead, so we
+        // don't need to create any other.
+        if (ptype->generateCode() && ptype->customConversion() != nullptr)
+            result.append({getTypeIndexVariableName(ptype), pCount++, {}});
     }
 
     for (const AbstractMetaType &container : api().instantiatedContainers()) {
-        _writeTypeIndexValue(macrosStream, getTypeIndexVariableName(container), pCount);
-        macrosStream << ", // " << container.cppSignature() << '\n';
-        pCount++;
+        result.append({getTypeIndexVariableName(container),
+                       pCount++, container.cppSignature()});
     }
 
     // Because on win32 the compiler will not accept a zero length array.
     if (pCount == 0)
         pCount++;
-    _writeTypeIndexValue(macrosStream, QStringLiteral("SBK_%1_CONVERTERS_IDX_COUNT")
-                                       .arg(moduleName()), pCount);
-    macrosStream << "\n};\n";
+     result.append({"SBK_"_L1 + moduleName() + "_CONVERTERS_IDX_COUNT"_L1,
+                   pCount, {}});
+    return result;
+}
+
+// PYSIDE-2404: Write the enums in unchanged case for reuse in type imports.
+//              For conpatibility, we create them in uppercase, too and with
+//              doubled index for emulating the former type-only case.
+//
+// FIXME: Remove in PySide 7. (See the note in `parser.py`)
+//
+static IndexValue typeIndexUpper(struct IndexValue const &ti)
+{
+    QString modi = ti.name.toUpper();
+    if (modi == ti.name)
+        modi = u"// "_s + modi;
+    return {modi, ti.value * 2, ti.comment};
+}
+
+bool HeaderGenerator::finishGeneration()
+{
+    // Generate the main header for this module. This header should be included
+    // by binding modules extending on top of this one.
+    ModuleHeaderParameters parameters;
+    ModuleHeaderParameters privateParameters;
+    StringStream macrosStream(TextStream::Language::Cpp);
+
+    const auto snips = TypeDatabase::instance()->defaultTypeSystemType()->codeSnips();
+    writeModuleCodeSnips(macrosStream, snips, TypeSystem::CodeSnipPositionDeclaration,
+                         TypeSystem::TargetLangCode);
+
+    auto classList = api().classes();
+
+    std::sort(classList.begin(), classList.end(),
+              [](const AbstractMetaClassCPtr &a, const AbstractMetaClassCPtr &b) {
+                  return a->typeEntry()->sbkIndex() < b->typeEntry()->sbkIndex();
+              });
+
+    const auto typeIndexes = collectTypeIndexes(classList);
+
+    macrosStream << "\n// Type indices\nenum [[deprecated]] : int {\n";
+    for (const auto &ti : typeIndexes)
+        macrosStream << typeIndexUpper(ti);
+    macrosStream << "};\n";
+
+    macrosStream << "\n// Type indices\nenum : int {\n";
+    for (const auto &ti : typeIndexes)
+        macrosStream << ti;
+    macrosStream << "};\n\n";
+
+    // FIXME: Remove backwards compatible variable in PySide 7.
+    macrosStream << "// This variable stores all Python types exported by this module.\n";
+    macrosStream << "extern Shiboken::Module::TypeInitStruct *" << cppApiVariableName() << ";\n\n";
+    macrosStream << "// This variable stores all Python types exported by this module ";
+    macrosStream << "in a backwards compatible way with identical indexing.\n";
+    macrosStream << "[[deprecated]] extern PyTypeObject **" << cppApiVariableNameOld() << ";\n\n";
+    macrosStream << "// This variable stores the Python module object exported by this module.\n";
+    macrosStream << "extern PyObject *" << pythonModuleObjectName() << ";\n\n";
+    macrosStream << "// This variable stores all type converters exported by this module.\n";
+    macrosStream << "extern SbkConverter **" << convertersVariableName() << ";\n\n";
+
+    // TODO-CONVERTER ------------------------------------------------------------------------------
+    // Using a counter would not do, a fix must be made to APIExtractor's getTypeIndex().
+    const auto converterIndexes = collectConverterIndexes();
+    macrosStream << "// Converter indices\nenum [[deprecated]] : int {\n";
+    for (const auto &ci : converterIndexes)
+        macrosStream << typeIndexUpper(ci);
+    macrosStream << "};\n\n";
+
+    macrosStream << "// Converter indices\nenum : int {\n";
+    for (const auto &ci : converterIndexes)
+        macrosStream << ci;
+    macrosStream << "};\n";
 
     formatTypeDefEntries(macrosStream);
 
@@ -627,28 +738,36 @@ bool HeaderGenerator::finishGeneration()
 
     for (const AbstractMetaEnum &cppEnum : api().globalEnums()) {
         if (!cppEnum.isAnonymous()) {
-            parameters.includes.insert(cppEnum.typeEntry()->include());
+            const auto te = cppEnum.typeEntry();
+            if (te->hasConfigCondition())
+                parameters.conditionalIncludes[te->configCondition()].append(te->include());
+            else
+                parameters.includes.insert(cppEnum.typeEntry()->include());
             writeSbkTypeFunction(typeFunctions, cppEnum);
         }
     }
 
     StringStream protEnumsSurrogates(TextStream::Language::Cpp);
-    for (auto metaClass : classList) {
+    for (const auto &metaClass : classList) {
         const auto classType = metaClass->typeEntry();
         if (!shouldGenerate(classType))
             continue;
 
-        //Includes
+        // Includes
         const bool isPrivate = classType->isPrivate();
         auto &par = isPrivate ? privateParameters : parameters;
         const auto classInclude = classType->include();
+        const bool hasConfigCondition = classType->hasConfigCondition();
         if (leanHeaders() && canForwardDeclare(metaClass))
             par.forwardDeclarations.append(metaClass);
+        else if (hasConfigCondition)
+            par.conditionalIncludes[classType->configCondition()].append(classInclude);
         else
             par.includes.insert(classInclude);
 
         auto &typeFunctionsStr = isPrivate ? privateTypeFunctions : typeFunctions;
 
+        ConfigurableScope configScope(typeFunctionsStr, classType);
         for (const AbstractMetaEnum &cppEnum : metaClass->enums()) {
             if (cppEnum.isAnonymous() || cppEnum.isPrivate())
                 continue;
@@ -688,6 +807,7 @@ bool HeaderGenerator::finishGeneration()
     }
 
     s << "#include <sbkpython.h>\n";
+    s << "#include <sbkmodule.h>\n";
     s << "#include <sbkconverter.h>\n";
 
     QStringList requiredTargetImports = TypeDatabase::instance()->requiredTargetImports();
@@ -701,6 +821,7 @@ bool HeaderGenerator::finishGeneration()
     s << "// Bound library includes\n";
     for (const Include &include : parameters.includes)
         s << include;
+    s << parameters.conditionalIncludes;
 
     if (leanHeaders()) {
         writeForwardDeclarations(s, parameters.forwardDeclarations);
@@ -751,8 +872,7 @@ void HeaderGenerator::writePrivateHeader(const QString &moduleHeaderDir,
     TextStream &ps = privateFile.stream;
     ps.setLanguage(TextStream::Language::Cpp);
     QString privateIncludeShield =
-        publicIncludeShield.left(publicIncludeShield.size() - 2)
-        + QStringLiteral("_P_H");
+        publicIncludeShield.left(publicIncludeShield.size() - 2) + "_P_H"_L1;
 
     ps << licenseComment()<< "\n\n";
 
@@ -761,6 +881,7 @@ void HeaderGenerator::writePrivateHeader(const QString &moduleHeaderDir,
 
     for (const Include &include : parameters.includes)
         ps << include;
+    ps << parameters.conditionalIncludes;
     ps << '\n';
 
     if (leanHeaders())
@@ -789,36 +910,52 @@ void HeaderGenerator::writeTypeFunctions(TextStream &s, const QString &typeFunct
         s << "QT_WARNING_POP\n";
 }
 
-void HeaderGenerator::writeProtectedEnumSurrogate(TextStream &s, const AbstractMetaEnum &cppEnum) const
+void HeaderGenerator::writeProtectedEnumSurrogate(TextStream &s, const AbstractMetaEnum &cppEnum)
 {
     if (avoidProtectedHack() && cppEnum.isProtected())
         s << "enum " << protectedEnumSurrogateName(cppEnum) << " {};\n";
 }
 
-void HeaderGenerator::writeSbkTypeFunction(TextStream &s, const AbstractMetaEnum &cppEnum) const
+void HeaderGenerator::writeSbkTypeFunction(TextStream &s, const AbstractMetaEnum &cppEnum)
 {
      const QString enumName = avoidProtectedHack() && cppEnum.isProtected()
         ? protectedEnumSurrogateName(cppEnum)
         : cppEnum.qualifiedCppName();
-
-    s << "template<> inline PyTypeObject *SbkType< ::" << enumName << " >() ";
-    s << "{ return " << cpythonTypeNameExt(cppEnum.typeEntry()) << "; }\n";
+    const auto te = cppEnum.typeEntry();
+    ConfigurableScope configScope(s, te);
+    s << "template<> inline PyTypeObject *SbkType< " << m_gsp << enumName << " >() ";
+    s << "{ return " << cpythonTypeNameExt(te) << "; }\n";
 
     const auto flag = cppEnum.typeEntry()->flags();
-    if (!flag.isNull()) {
-        s <<  "template<> inline PyTypeObject *SbkType< ::" << flag->name() << " >() "
+    if (flag) {
+        s <<  "template<> inline PyTypeObject *SbkType< " << m_gsp << flag->name() << " >() "
           << "{ return " << cpythonTypeNameExt(flag) << "; }\n";
     }
 }
 
-void HeaderGenerator::writeSbkTypeFunction(TextStream &s, const AbstractMetaClass *cppClass)
+void HeaderGenerator::writeSbkTypeFunction(TextStream &s, const AbstractMetaClassCPtr &cppClass)
 {
-    s <<  "template<> inline PyTypeObject *SbkType< ::" << cppClass->qualifiedCppName() << " >() "
-      <<  "{ return reinterpret_cast<PyTypeObject *>(" << cpythonTypeNameExt(cppClass->typeEntry()) << "); }\n";
+    s << "template<> inline PyTypeObject *SbkType< "
+      << getFullTypeName(cppClass) << " >() "
+      << "{ return " << cpythonTypeNameExt(cppClass->typeEntry()) << "; }\n";
 }
 
 void HeaderGenerator::writeSbkTypeFunction(TextStream &s, const AbstractMetaType &metaType)
 {
-    s <<  "template<> inline PyTypeObject *SbkType< ::" << metaType.cppSignature() << " >() "
+    s <<  "template<> inline PyTypeObject *SbkType< "
+      << m_gsp << metaType.cppSignature() << " >() "
       <<  "{ return " << cpythonTypeNameExt(metaType) << "; }\n";
 }
+
+void HeaderGenerator::writeModuleCodeSnips(TextStream &s, const CodeSnipList &codeSnips,
+                                           TypeSystem::CodeSnipPosition position,
+                                           TypeSystem::Language language) const
+{
+    if (!codeSnips.isEmpty()) {
+        try {
+            writeCodeSnips(s, codeSnips, position, language);
+        } catch (const std::exception &e) {
+            throw Exception(msgSnippetError("module header of "_L1 + moduleName(), e.what()));
+        }
+    }
+}
diff --git a/sources/shiboken6/generator/shiboken/headergenerator.h b/sources/shiboken6/generator/shiboken/headergenerator.h
index f1735cd9f..03b98e743 100644
--- a/sources/shiboken6/generator/shiboken/headergenerator.h
+++ b/sources/shiboken6/generator/shiboken/headergenerator.h
@@ -6,9 +6,12 @@
 
 #include "shibokengenerator.h"
 #include "include.h"
+#include "modifications_typedefs.h"
 
+#include <QtCore/QList>
 #include <QtCore/QSet>
 
+struct IndexValue;
 class AbstractMetaFunction;
 struct ModuleHeaderParameters;
 
@@ -18,11 +21,9 @@ struct ModuleHeaderParameters;
 class HeaderGenerator : public ShibokenGenerator
 {
 public:
-    OptionDescriptions options() const override { return OptionDescriptions(); }
-
     const char *name() const override { return "Header generator"; }
 
-    static QString headerFileNameForContext(const GeneratorContext &context);
+    static const char *protectedHackDefine;
 
 protected:
     QString fileNameForContext(const GeneratorContext &context) const override;
@@ -30,26 +31,44 @@ protected:
     bool finishGeneration() override;
 
 private:
-    void writeCopyCtor(TextStream &s, const AbstractMetaClass *metaClass) const;
-    void writeFunction(TextStream &s, const AbstractMetaFunctionCPtr &func,
-                       FunctionGeneration generation);
-    void writeSbkTypeFunction(TextStream &s, const AbstractMetaEnum &cppEnum) const;
-    static void writeSbkTypeFunction(TextStream &s, const AbstractMetaClass *cppClass) ;
-    static void writeSbkTypeFunction(TextStream &s, const AbstractMetaType &metaType) ;
-    void writeTypeIndexValueLine(TextStream &s, const ApiExtractorResult &api,
-                                 const TypeEntryCPtr &typeEntry);
-    void writeTypeIndexValueLines(TextStream &s, const ApiExtractorResult &api,
-                                  const AbstractMetaClass *metaClass);
-    void writeProtectedEnumSurrogate(TextStream &s, const AbstractMetaEnum &cppEnum) const;
+    using InheritedOverloadSet = QSet<AbstractMetaFunctionCPtr>;
+    using IndexValues = QList<IndexValue>;
+
+    IndexValues collectTypeIndexes(const AbstractMetaClassCList &classList);
+    IndexValues collectConverterIndexes() const;
+
+    static void writeCopyCtor(TextStream &s, const AbstractMetaClassCPtr &metaClass);
+    void writeFunction(TextStream &s,
+                       const AbstractMetaFunctionCPtr &func,
+                       InheritedOverloadSet *inheritedOverloads,
+                       FunctionGeneration generation) const;
+    static void writeSbkTypeFunction(TextStream &s, const AbstractMetaEnum &cppEnum);
+    static void writeSbkTypeFunction(TextStream &s, const AbstractMetaClassCPtr &cppClass);
+    static void writeSbkTypeFunction(TextStream &s, const AbstractMetaType &metaType);
+    void collectTypeEntryTypeIndexes(const ApiExtractorResult &api,
+                                     const TypeEntryCPtr &typeEntry,
+                                     IndexValues *indexValues);
+    void collectClassTypeIndexes(const ApiExtractorResult &api,
+                                 const AbstractMetaClassCPtr &metaClass,
+                                 IndexValues *indexValues);
+    static void writeProtectedEnumSurrogate(TextStream &s, const AbstractMetaEnum &cppEnum);
     void writeMemberFunctionWrapper(TextStream &s,
                                     const AbstractMetaFunctionCPtr &func,
                                     const QString &postfix = {}) const;
     void writePrivateHeader(const QString &moduleHeaderDir,
                             const QString &publicIncludeShield,
                             const ModuleHeaderParameters &parameters);
-    void writeTypeFunctions(TextStream &s, const QString &typeFunctions);
+    static void writeTypeFunctions(TextStream &s, const QString &typeFunctions);
+    void writeWrapperClassDeclaration(TextStream &s,
+                                      const QString &wrapperName,
+                                      const GeneratorContext &classContext) const;
+    void writeWrapperClass(TextStream &s, const QString &wrapperName, const GeneratorContext &classContext) const;
+    void writeInheritedWrapperClassDeclaration(TextStream &s,
+                                               const GeneratorContext &classContext) const;
+    void writeModuleCodeSnips(TextStream &s, const CodeSnipList &codeSnips,
+                              TypeSystem::CodeSnipPosition position,
+                              TypeSystem::Language language) const;
 
-    QSet<AbstractMetaFunctionCPtr> m_inheritedOverloads;
     AbstractMetaClassCList m_alternateTemplateIndexes;
 };
 
diff --git a/sources/shiboken6/generator/shiboken/overloaddata.cpp b/sources/shiboken6/generator/shiboken/overloaddata.cpp
index a5594791e..c28fcdc1a 100644
--- a/sources/shiboken6/generator/shiboken/overloaddata.cpp
+++ b/sources/shiboken6/generator/shiboken/overloaddata.cpp
@@ -16,7 +16,6 @@
 #include "pytypenames.h"
 #include "textstream.h"
 #include "exception.h"
-#include "messages.h"
 
 #include "qtcompat.h"
 
@@ -126,6 +125,7 @@ using OverloadGraph = Graph<QString>;
 void OverloadDataRootNode::sortNextOverloads(const ApiExtractorResult &api)
 {
     QHash<QString, OverloadDataList> typeToOverloads;
+    using Edge = std::pair<QString, QString>;
 
     bool checkPyObject = false;
     bool checkPySequence = false;
@@ -135,10 +135,10 @@ void OverloadDataRootNode::sortNextOverloads(const ApiExtractorResult &api)
 
     // Primitive types that are not int, long, short,
     // char and their respective unsigned counterparts.
-    static const QStringList nonIntegerPrimitives{floatT(), doubleT(), boolT()};
+    static const QStringList nonIntegerPrimitives{floatT, doubleT, boolT};
 
     // Signed integer primitive types.
-    static const QStringList signedIntegerPrimitives{intT(), shortT(), longT(), longLongT()};
+    static const QStringList signedIntegerPrimitives{intT, shortT, longT, longLongT};
 
     // sort the children overloads
     for (const auto &ov : std::as_const(m_children))
@@ -162,15 +162,15 @@ void OverloadDataRootNode::sortNextOverloads(const ApiExtractorResult &api)
             it.value().append(ov);
         }
 
-        if (!checkPyObject && typeName == cPyObjectT())
+        if (!checkPyObject && typeName == cPyObjectT)
             checkPyObject = true;
-        else if (!checkPySequence && typeName == cPySequenceT())
+        else if (!checkPySequence && typeName == cPySequenceT)
             checkPySequence = true;
-        else if (!checkPyBuffer && typeName == cPyBufferT())
+        else if (!checkPyBuffer && typeName == cPyBufferT)
             checkPyBuffer = true;
-        else if (!checkQVariant && typeName == qVariantT())
+        else if (!checkQVariant && typeName == qVariantT)
             checkQVariant = true;
-        else if (!checkQString && typeName == qStringT())
+        else if (!checkQString && typeName == qStringT)
             checkQString = true;
 
         for (const auto &instantiation : ov->argType().instantiations()) {
@@ -196,9 +196,9 @@ void OverloadDataRootNode::sortNextOverloads(const ApiExtractorResult &api)
 
     // Create the graph of type dependencies based on implicit conversions.
     // All C++ primitive types, add any forgotten type AT THE END OF THIS LIST!
-    static const QStringList primitiveTypes{intT(), unsignedIntT(), longT(), unsignedLongT(),
-        shortT(), unsignedShortT(), boolT(), unsignedCharT(), charT(), floatT(),
-        doubleT(), constCharPtrT()};
+    static const QStringList primitiveTypes{intT, unsignedIntT, longT, unsignedLongT,
+        shortT, unsignedShortT, boolT, unsignedCharT, charT, floatT,
+        doubleT, constCharPtrT};
 
     QStringList foundPrimitiveTypeIds;
     for (const auto &p : primitiveTypes) {
@@ -207,7 +207,7 @@ void OverloadDataRootNode::sortNextOverloads(const ApiExtractorResult &api)
     }
 
     if (checkPySequence && checkPyObject)
-        graph.addEdge(cPySequenceT(), cPyObjectT());
+        graph.addEdge(cPySequenceT, cPyObjectT);
 
     QStringList classesWithIntegerImplicitConversion;
 
@@ -226,7 +226,7 @@ void OverloadDataRootNode::sortNextOverloads(const ApiExtractorResult &api)
             else
                 convertibleType = getTypeName(function->arguments().constFirst().type());
 
-            if (convertibleType == intT() || convertibleType == unsignedIntT())
+            if (convertibleType == intT || convertibleType == unsignedIntT)
                 classesWithIntegerImplicitConversion << targetTypeEntryName;
 
             if (!graph.hasNode(convertibleType))
@@ -246,7 +246,7 @@ void OverloadDataRootNode::sortNextOverloads(const ApiExtractorResult &api)
             if (!metaClass)
                 throw Exception(msgArgumentClassNotFound(m_overloads.constFirst(), te));
             const auto &ancestors = metaClass->allTypeSystemAncestors();
-            for (const AbstractMetaClass *ancestor : ancestors) {
+            for (const auto &ancestor : ancestors) {
                 QString ancestorTypeName = ancestor->typeEntry()->name();
                 if (!graph.hasNode(ancestorTypeName))
                     continue;
@@ -288,28 +288,28 @@ void OverloadDataRootNode::sortNextOverloads(const ApiExtractorResult &api)
 
 
         if ((checkPySequence || checkPyObject || checkPyBuffer)
-            && !targetTypeEntryName.contains(cPyObjectT())
-            && !targetTypeEntryName.contains(cPyBufferT())
-            && !targetTypeEntryName.contains(cPySequenceT())) {
+            && !targetTypeEntryName.contains(cPyObjectT)
+            && !targetTypeEntryName.contains(cPyBufferT)
+            && !targetTypeEntryName.contains(cPySequenceT)) {
             if (checkPySequence) {
                 // PySequence will be checked after all more specific types, but before PyObject.
-                graph.addEdge(targetTypeEntryName, cPySequenceT());
+                graph.addEdge(targetTypeEntryName, cPySequenceT);
             } else if (checkPyBuffer) {
                 // PySequence will be checked after all more specific types, but before PyObject.
-                graph.addEdge(targetTypeEntryName, cPyBufferT());
+                graph.addEdge(targetTypeEntryName, cPyBufferT);
             } else {
                 // Add dependency on PyObject, so its check is the last one (too generic).
-                graph.addEdge(targetTypeEntryName, cPyObjectT());
+                graph.addEdge(targetTypeEntryName, cPyObjectT);
             }
-        } else if (checkQVariant && targetTypeEntryName != qVariantT()) {
-            if (!graph.containsEdge(qVariantT(), targetTypeEntryName)) // Avoid cyclic dependency.
-                graph.addEdge(targetTypeEntryName, qVariantT());
+        } else if (checkQVariant && targetTypeEntryName != qVariantT) {
+            if (!graph.containsEdge(qVariantT, targetTypeEntryName)) // Avoid cyclic dependency.
+                graph.addEdge(targetTypeEntryName, qVariantT);
         } else if (checkQString && ov->argType().isPointer()
-            && targetTypeEntryName != qStringT()
-            && targetTypeEntryName != qByteArrayT()
-            && (!checkPyObject || targetTypeEntryName != cPyObjectT())) {
-            if (!graph.containsEdge(qStringT(), targetTypeEntryName)) // Avoid cyclic dependency.
-                graph.addEdge(targetTypeEntryName, qStringT());
+            && targetTypeEntryName != qStringT
+            && targetTypeEntryName != qByteArrayT
+            && (!checkPyObject || targetTypeEntryName != cPyObjectT)) {
+            if (!graph.containsEdge(qStringT, targetTypeEntryName)) // Avoid cyclic dependency.
+                graph.addEdge(targetTypeEntryName, qStringT);
         }
 
         if (targetType.isEnum()) {
@@ -320,8 +320,19 @@ void OverloadDataRootNode::sortNextOverloads(const ApiExtractorResult &api)
     }
 
     // QByteArray args need to be checked after QString args
-    if (graph.hasNode(qStringT()) && graph.hasNode(qByteArrayT()))
-        graph.addEdge(qStringT(), qByteArrayT());
+    if (graph.hasNode(qStringT) && graph.hasNode(qByteArrayT))
+        graph.addEdge(qStringT, qByteArrayT);
+
+    static const Edge rangeOrder[] =
+        {{doubleT, floatT},
+         {longLongT, longT}, {longLongT, intT}, {intT, shortT},
+         {unsignedLongLongT, unsignedLongT}, {unsignedLongLongT, unsignedT},
+         {unsignedLongLongT, unsignedIntT}, {unsignedT, unsignedShortT}
+    };
+    for (const auto &r : rangeOrder) {
+        if (graph.hasNode(r.first) && graph.hasNode(r.second))
+            graph.addEdge(r.first, r.second);
+    }
 
     for (const auto &ov : std::as_const(m_children)) {
         const AbstractMetaType &targetType = ov->argType();
@@ -381,8 +392,7 @@ static std::pair<int, int> getMinMaxArgs(const AbstractMetaFunctionCPtr &func)
     int defaultValueIndex = -1;
     const auto &arguments = func->arguments();
     int argIndex = 0;
-    for (qsizetype i = 0, size = arguments.size(); i < size; ++i) {
-        const auto &arg =  arguments.at(i);
+    for (const auto &arg : arguments) {
         if (!arg.isModifiedRemoved()) {
             if (defaultValueIndex < 0 && arg.hasDefaultValueExpression())
                 defaultValueIndex = argIndex;
@@ -475,13 +485,13 @@ OverloadDataNode *OverloadDataRootNode::addOverloadDataNode(const AbstractMetaFu
         }
     }
 
-    if (overloadData.isNull()) {
+    if (!overloadData) {
         const int argpos = argPos() + 1;
         overloadData.reset(new OverloadDataNode(func, this, arg, argpos));
         m_children.append(overloadData);
     }
 
-    return overloadData.data();
+    return overloadData.get();
 }
 
 bool OverloadData::hasNonVoidReturnType() const
@@ -604,7 +614,7 @@ const AbstractMetaArgument *OverloadDataNode::overloadArgument(const AbstractMet
 bool OverloadDataRootNode::nextArgumentHasDefaultValue() const
 {
     for (const auto &overloadData : m_children) {
-        if (!overloadData->getFunctionWithDefaultValue().isNull())
+        if (overloadData->getFunctionWithDefaultValue())
             return true;
     }
     return false;
@@ -612,20 +622,20 @@ bool OverloadDataRootNode::nextArgumentHasDefaultValue() const
 
 static const OverloadDataRootNode *_findNextArgWithDefault(const OverloadDataRootNode *overloadData)
 {
-    if (!overloadData->getFunctionWithDefaultValue().isNull())
+    if (overloadData->getFunctionWithDefaultValue())
         return overloadData;
 
     const OverloadDataRootNode *result = nullptr;
     const OverloadDataList &data = overloadData->children();
     for (const auto &odata : data) {
-        const auto *tmp = _findNextArgWithDefault(odata.data());
+        const auto *tmp = _findNextArgWithDefault(odata.get());
         if (!result || (tmp && result->argPos() > tmp->argPos()))
             result = tmp;
     }
     return result;
 }
 
-const OverloadDataRootNode *OverloadDataRootNode::findNextArgWithDefault()
+const OverloadDataRootNode *OverloadDataRootNode::findNextArgWithDefault() const
 {
     return _findNextArgWithDefault(this);
 }
diff --git a/sources/shiboken6/generator/shiboken/overloaddata.h b/sources/shiboken6/generator/shiboken/overloaddata.h
index 3fc9eef50..875a5a8b5 100644
--- a/sources/shiboken6/generator/shiboken/overloaddata.h
+++ b/sources/shiboken6/generator/shiboken/overloaddata.h
@@ -9,13 +9,14 @@
 
 #include <QtCore/QBitArray>
 #include <QtCore/QList>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
 
 QT_FORWARD_DECLARE_CLASS(QDebug)
 QT_FORWARD_DECLARE_CLASS(QTextStream)
 
 class OverloadDataNode;
-using OverloadDataNodePtr = QSharedPointer<OverloadDataNode>;
+using OverloadDataNodePtr = std::shared_ptr<OverloadDataNode>;
 using OverloadDataList = QList<OverloadDataNodePtr>;
 
 /// The root node of OverloadData. It contains all functions
@@ -45,7 +46,7 @@ public:
     AbstractMetaFunctionCPtr getFunctionWithDefaultValue() const;
 
     /// Returns the nearest occurrence, including this instance, of an argument with a default value.
-    const OverloadDataRootNode *findNextArgWithDefault();
+    const OverloadDataRootNode *findNextArgWithDefault() const;
     bool isFinalOccurrence(const AbstractMetaFunctionCPtr &func) const;
 
     int functionNumber(const AbstractMetaFunctionCPtr &func) const;
diff --git a/sources/shiboken6/generator/shiboken/pytypenames.h b/sources/shiboken6/generator/shiboken/pytypenames.h
index 696e0d88d..6c7658ff6 100644
--- a/sources/shiboken6/generator/shiboken/pytypenames.h
+++ b/sources/shiboken6/generator/shiboken/pytypenames.h
@@ -6,24 +6,24 @@
 
 #include <QtCore/QString>
 
-static inline QString pyBoolT() { return QStringLiteral("PyBool"); }
-static inline QString pyFloatT() { return QStringLiteral("PyFloat"); }
-static inline QString pyLongT() { return QStringLiteral("PyLong"); }
-static inline QString pyObjectT() { return QStringLiteral("object"); }
-static inline QString pyStrT() { return QStringLiteral("str"); }
+constexpr auto pyBoolT = QLatin1StringView ("PyBool");
+constexpr auto pyFloatT = QLatin1StringView ("PyFloat");
+constexpr auto pyLongT = QLatin1StringView ("PyLong");
+constexpr auto pyObjectT = QLatin1StringView ("object");
+constexpr auto pyStrT = QLatin1StringView ("str");
 
 // PYSIDE-1499: A custom type determined by existence of an `__fspath__` attribute.
-static inline QString pyPathLikeT() { return QStringLiteral("PyPathLike"); }
+constexpr auto pyPathLikeT = QLatin1StringView ("PyPathLike");
 
-static inline QString cPyBufferT() { return QStringLiteral("PyBuffer"); }
-static inline QString cPyListT() { return QStringLiteral("PyList"); }
-static inline QString cPyObjectT() { return QStringLiteral("PyObject"); }
-static inline QString cPySequenceT() { return QStringLiteral("PySequence"); }
-static inline QString cPyTypeObjectT() { return QStringLiteral("PyTypeObject"); }
+constexpr auto cPyBufferT = QLatin1StringView ("PyBuffer");
+constexpr auto cPyListT = QLatin1StringView ("PyList");
+constexpr auto cPyObjectT = QLatin1StringView ("PyObject");
+constexpr auto cPySequenceT = QLatin1StringView ("PySequence");
+constexpr auto cPyTypeObjectT = QLatin1StringView ("PyTypeObject");
 
 // numpy
-static inline QString cPyArrayObjectT() { return QStringLiteral("PyArrayObject"); }
+constexpr auto cPyArrayObjectT = QLatin1StringView ("PyArrayObject");
 
-static inline QString sbkCharT() { return QStringLiteral("SbkChar"); }
+constexpr auto sbkCharT = QLatin1StringView ("SbkChar");
 
 #endif // PYTYPENAMES_H
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
index 1810235b7..67fd9c994 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "shibokengenerator.h"
+#include "generatorstrings.h"
 #include "generatorargument.h"
 #include "defaultvalue.h"
 #include "generatorcontext.h"
@@ -20,12 +21,12 @@
 #include <messages.h>
 #include <modifications.h>
 #include "overloaddata.h"
+#include <optionsparser.h>
 #include "propertyspec.h"
 #include "pytypenames.h"
 #include <reporthandler.h>
 #include <textstream.h>
 #include <typedatabase.h>
-#include <abstractmetabuilder.h>
 #include <containertypeentry.h>
 #include <customtypenentry.h>
 #include <enumtypeentry.h>
@@ -33,6 +34,7 @@
 #include <namespacetypeentry.h>
 #include <primitivetypeentry.h>
 #include <pythontypeentry.h>
+#include <smartpointertypeentry.h>
 #include <valuetypeentry.h>
 
 #include <iostream>
@@ -42,44 +44,73 @@
 #include <QtCore/QDir>
 #include <QtCore/QDebug>
 #include <QtCore/QRegularExpression>
+
+#include <algorithm>
 #include <limits>
 #include <memory>
+#include <utility>
 
 using namespace Qt::StringLiterals;
 
-static const char PARENT_CTOR_HEURISTIC[] = "enable-parent-ctor-heuristic";
-static const char RETURN_VALUE_HEURISTIC[] = "enable-return-value-heuristic";
-static const char DISABLE_VERBOSE_ERROR_MESSAGES[] = "disable-verbose-error-messages";
-static const char USE_ISNULL_AS_NB_NONZERO[] = "use-isnull-as-nb_nonzero";
-static const char USE_OPERATOR_BOOL_AS_NB_NONZERO[] = "use-operator-bool-as-nb_nonzero";
-static const char WRAPPER_DIAGNOSTICS[] = "wrapper-diagnostics";
-static const char NO_IMPLICIT_CONVERSIONS[] = "no-implicit-conversions";
-static const char LEAN_HEADERS[] = "lean-headers";
-
-const QString CPP_ARG = u"cppArg"_s;
-const QString CPP_ARG_REMOVED = u"removed_cppArg"_s;
-const QString CPP_RETURN_VAR = u"cppResult"_s;
-const QString CPP_SELF_VAR = u"cppSelf"_s;
-const QString NULL_PTR = u"nullptr"_s;
-const QString PYTHON_ARG = u"pyArg"_s;
-const QString PYTHON_ARGS = u"pyArgs"_s;
-const QString PYTHON_OVERRIDE_VAR = u"pyOverride"_s;
-const QString PYTHON_RETURN_VAR = u"pyResult"_s;
-const QString PYTHON_TO_CPP_VAR = u"pythonToCpp"_s;
-const QString SMART_POINTER_GETTER = u"kSmartPointerGetter"_s;
-
-const QString CONV_RULE_OUT_VAR_SUFFIX = u"_out"_s;
-const QString BEGIN_ALLOW_THREADS =
-    u"PyThreadState *_save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS"_s;
-const QString END_ALLOW_THREADS = u"PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS"_s;
+static constexpr auto PARENT_CTOR_HEURISTIC = "enable-parent-ctor-heuristic"_L1;
+static constexpr auto RETURN_VALUE_HEURISTIC = "enable-return-value-heuristic"_L1;
+static constexpr auto DISABLE_VERBOSE_ERROR_MESSAGES = "disable-verbose-error-messages"_L1;
+static constexpr auto USE_ISNULL_AS_NB_BOOL = "use-isnull-as-nb-bool"_L1;
+// FIXME PYSIDE 7: Remove USE_ISNULL_AS_NB_NONZERO/USE_OPERATOR_BOOL_AS_NB_NONZERO
+static constexpr auto USE_ISNULL_AS_NB_NONZERO = "use-isnull-as-nb_nonzero"_L1;
+static constexpr auto USE_OPERATOR_BOOL_AS_NB_BOOL = "use-operator-bool-as-nb-bool"_L1;
+static constexpr auto USE_OPERATOR_BOOL_AS_NB_NONZERO = "use-operator-bool-as-nb-nonzero"_L1;
+static constexpr auto WRAPPER_DIAGNOSTICS = "wrapper-diagnostics"_L1;
+static constexpr auto NO_IMPLICIT_CONVERSIONS = "no-implicit-conversions"_L1;
+static constexpr auto LEAN_HEADERS = "lean-headers"_L1;
+
+QString CPP_ARG_N(int i)
+{
+    return CPP_ARG + QString::number(i);
+}
+
+constexpr auto CPP_ARG_REMOVED_PREFIX = "removed_cppArg"_L1;
+
+QString CPP_ARG_REMOVED(int i)
+{
+    return CPP_ARG_REMOVED_PREFIX + QString::number(i);
+}
+
+const char *const METHOD_DEF_SENTINEL = "{nullptr, nullptr, 0, nullptr} // Sentinel\n";
+const char *const PYTHON_TO_CPPCONVERSION_STRUCT = "Shiboken::Conversions::PythonToCppConversion";
+
+const char *const openTargetExternC =  R"(
+// Target ---------------------------------------------------------
+
+extern "C" {
+)";
+const char *const closeExternC =  "} // extern \"C\"\n\n";
+const char *const richCompareComment =
+    "// PYSIDE-74: By default, we redirect to object's tp_richcompare (which is `==`, `!=`).\n";
+
+struct ShibokenGeneratorOptions
+{
+    bool useCtorHeuristic = false;
+    bool userReturnValueHeuristic = false;
+    bool verboseErrorMessagesDisabled = false;
+    bool useIsNullAsNbBool = false;
+    // FIXME PYSIDE 7 Flip m_leanHeaders default or remove?
+    bool leanHeaders = false;
+    bool useOperatorBoolAsNbBool = false;
+    // FIXME PYSIDE 7 Flip generateImplicitConversions default or remove?
+    bool generateImplicitConversions = true;
+    bool wrapperDiagnostics = false;
+};
 
 struct GeneratorClassInfoCacheEntry
 {
     ShibokenGenerator::FunctionGroups functionGroups;
+    QList<AbstractMetaFunctionCList> numberProtocolOperators;
+    BoolCastFunctionOptional boolCastFunctionO;
     bool needsGetattroFunction = false;
 };
 
-using GeneratorClassInfoCache = QHash<const AbstractMetaClass *, GeneratorClassInfoCacheEntry>;
+using GeneratorClassInfoCache = QHash<AbstractMetaClassCPtr, GeneratorClassInfoCacheEntry>;
 
 Q_GLOBAL_STATIC(GeneratorClassInfoCache, generatorClassInfoCache)
 
@@ -103,6 +134,10 @@ const ShibokenGenerator::TypeSystemConverterRegExps &
     return result;
 }
 
+// Options are static to avoid duplicated handling since ShibokenGenerator
+// is instantiated for HeaderGenerator and CppGenerator.
+ShibokenGeneratorOptions ShibokenGenerator::m_options;
+
 ShibokenGenerator::ShibokenGenerator() = default;
 
 ShibokenGenerator::~ShibokenGenerator() = default;
@@ -111,32 +146,32 @@ ShibokenGenerator::~ShibokenGenerator() = default;
 static const QHash<QString, QString> &primitiveTypesCorrespondences()
 {
     static const QHash<QString, QString> result = {
-        {u"bool"_s, pyBoolT()},
-        {u"char"_s, sbkCharT()},
-        {u"signed char"_s, sbkCharT()},
-        {u"unsigned char"_s, sbkCharT()},
-        {intT(), pyLongT()},
-        {u"signed int"_s, pyLongT()},
-        {u"uint"_s, pyLongT()},
-        {u"unsigned int"_s, pyLongT()},
-        {shortT(), pyLongT()},
-        {u"ushort"_s, pyLongT()},
-        {u"signed short"_s, pyLongT()},
-        {u"signed short int"_s, pyLongT()},
-        {unsignedShortT(), pyLongT()},
-        {u"unsigned short int"_s, pyLongT()},
-        {longT(), pyLongT()},
-        {doubleT(), pyFloatT()},
-        {floatT(), pyFloatT()},
-        {u"unsigned long"_s, pyLongT()},
-        {u"signed long"_s, pyLongT()},
-        {u"ulong"_s, pyLongT()},
-        {u"unsigned long int"_s, pyLongT()},
-        {u"long long"_s, pyLongT()},
-        {u"__int64"_s, pyLongT()},
-        {u"unsigned long long"_s, pyLongT()},
-        {u"unsigned __int64"_s, pyLongT()},
-        {u"size_t"_s, pyLongT()}
+        {u"bool"_s, pyBoolT},
+        {u"char"_s, sbkCharT},
+        {u"signed char"_s, sbkCharT},
+        {u"unsigned char"_s, sbkCharT},
+        {intT, pyLongT},
+        {u"signed int"_s, pyLongT},
+        {u"uint"_s, pyLongT},
+        {u"unsigned int"_s, pyLongT},
+        {shortT, pyLongT},
+        {u"ushort"_s, pyLongT},
+        {u"signed short"_s, pyLongT},
+        {u"signed short int"_s, pyLongT},
+        {unsignedShortT, pyLongT},
+        {u"unsigned short int"_s, pyLongT},
+        {longT, pyLongT},
+        {doubleT, pyFloatT},
+        {floatT, pyFloatT},
+        {u"unsigned long"_s, pyLongT},
+        {u"signed long"_s, pyLongT},
+        {u"ulong"_s, pyLongT},
+        {u"unsigned long int"_s, pyLongT},
+        {u"long long"_s, pyLongT},
+        {u"__int64"_s, pyLongT},
+        {u"unsigned long long"_s, pyLongT},
+        {u"unsigned __int64"_s, pyLongT},
+        {u"size_t"_s, pyLongT}
     };
     return result;
 }
@@ -146,24 +181,24 @@ const QHash<QString, QChar> &ShibokenGenerator::formatUnits()
     static const QHash<QString, QChar> result = {
         {u"char"_s, u'b'},
         {u"unsigned char"_s, u'B'},
-        {intT(), u'i'},
+        {intT, u'i'},
         {u"unsigned int"_s, u'I'},
-        {shortT(), u'h'},
-        {unsignedShortT(), u'H'},
-        {longT(), u'l'},
-        {unsignedLongLongT(), u'k'},
-        {longLongT(), u'L'},
+        {shortT, u'h'},
+        {unsignedShortT, u'H'},
+        {longT, u'l'},
+        {unsignedLongLongT, u'k'},
+        {longLongT, u'L'},
         {u"__int64"_s, u'L'},
-        {unsignedLongLongT(), u'K'},
+        {unsignedLongLongT, u'K'},
         {u"unsigned __int64"_s, u'K'},
-        {doubleT(), u'd'},
-        {floatT(), u'f'},
+        {doubleT, u'd'},
+        {floatT, u'f'},
     };
     return result;
 }
 
 QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType &cType,
-                                                         const AbstractMetaClass *context,
+                                                         const AbstractMetaClassCPtr &context,
                                                          Options options) const
 {
     if (cType.isArray()) {
@@ -180,7 +215,7 @@ QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType
     return translateType(cType, context, options);
 }
 
-bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass *metaClass) const
+bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClassCPtr &metaClass)
 {
     const auto wrapper = metaClass->cppWrapper();
     return wrapper.testFlag(AbstractMetaClass::CppVirtualMethodWrapper)
@@ -188,8 +223,17 @@ bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass *metaCl
             && wrapper.testFlag(AbstractMetaClass::CppProtectedHackWrapper));
 }
 
-ShibokenGenerator::FunctionGeneration
-    ShibokenGenerator::functionGeneration(const AbstractMetaFunctionCPtr &func) const
+bool ShibokenGenerator::shouldGenerateMetaObjectFunctions(const AbstractMetaClassCPtr &metaClass)
+{
+    return usePySideExtensions()
+        && (!avoidProtectedHack() || !metaClass->hasPrivateDestructor())
+           && !metaClass->typeEntry()->typeFlags()
+                  .testFlag(ComplexTypeEntry::DisableQtMetaObjectFunctions)
+        && isQObject(metaClass);
+}
+
+ShibokenGenerator::FunctionGeneration ShibokenGenerator::functionGeneration(
+    const AbstractMetaFunctionCPtr &func)
 {
     FunctionGeneration result;
 
@@ -232,7 +276,7 @@ ShibokenGenerator::FunctionGeneration
     // Check on virtuals (including operators).
     const bool isAbstract = func->isAbstract();
     if (!(isAbstract || func->isVirtual())
-        || func->attributes().testFlag(AbstractMetaFunction::FinalCppMethod)
+        || func->cppAttributes().testFlag(FunctionAttribute::Final)
         || func->isModifiedFinal()) {
         return result;
     }
@@ -240,7 +284,7 @@ ShibokenGenerator::FunctionGeneration
     // MetaObject virtuals only need to be declared; CppGenerator creates a
     // special implementation.
     if (functionType == AbstractMetaFunction::NormalFunction
-        && usePySideExtensions() && func->ownerClass()->isQObject()) {
+        && usePySideExtensions() && isQObject(func->ownerClass())) {
         const QString &name = func->name();
         if (name == u"metaObject"_s || name == u"qt_metacall") {
             result.setFlag(FunctionGenerationFlag::QMetaObjectMethod);
@@ -259,9 +303,9 @@ AbstractMetaFunctionCList ShibokenGenerator::implicitConversions(const TypeEntry
 {
     if (!generateImplicitConversions() || !t->isValue())
         return {};
-    auto vte = qSharedPointerCast<const ValueTypeEntry>(t);
+    auto vte = std::static_pointer_cast<const ValueTypeEntry>(t);
     auto customConversion = vte->customConversion();
-    if (!customConversion.isNull() && customConversion->replaceOriginalTargetToNativeConversions())
+    if (customConversion && customConversion->replaceOriginalTargetToNativeConversions())
         return {};
 
     auto result = api().implicitConversions(t);
@@ -273,7 +317,7 @@ AbstractMetaFunctionCList ShibokenGenerator::implicitConversions(const TypeEntry
     return result;
 }
 
-QString ShibokenGenerator::wrapperName(const AbstractMetaClass *metaClass) const
+QString ShibokenGenerator::wrapperName(const AbstractMetaClassCPtr &metaClass)
 {
     Q_ASSERT(shouldGenerateCppWrapper(metaClass));
     QString result = metaClass->name();
@@ -282,19 +326,55 @@ QString ShibokenGenerator::wrapperName(const AbstractMetaClass *metaClass) const
     return result + u"Wrapper"_s;
 }
 
-QString ShibokenGenerator::fullPythonClassName(const AbstractMetaClass *metaClass)
+QString ShibokenGenerator::fullPythonClassName(const AbstractMetaClassCPtr &metaClass)
 {
     QString fullClassName = metaClass->name();
-    const AbstractMetaClass *enclosing = metaClass->enclosingClass();
+    auto enclosing = metaClass->enclosingClass();
     while (enclosing) {
         if (NamespaceTypeEntry::isVisibleScope(enclosing->typeEntry()))
             fullClassName.prepend(enclosing->name() + u'.');
         enclosing = enclosing->enclosingClass();
     }
-    fullClassName.prepend(packageName() + u'.');
+    fullClassName.prepend(metaClass->typeEntry()->targetLangPackage() + u'.');
     return fullClassName;
 }
 
+QString ShibokenGenerator::headerFileNameForContext(const GeneratorContext &context)
+{
+    return fileNameForContextHelper(context, u"_wrapper.h"_s);
+}
+
+// PYSIDE-500: When avoiding the protected hack, also include the inherited
+// wrapper classes of the *current* module, because without the protected hack,
+// we sometimes need to cast inherited wrappers. Inherited classes
+// of *other* modules are completely regenerated by the header generator
+// since the wrapper headers are not installed.
+
+IncludeGroup ShibokenGenerator::baseWrapperIncludes(const GeneratorContext &classContext) const
+{
+    IncludeGroup result{u"Wrappers"_s, {}};
+    if (!classContext.useWrapper() || !avoidProtectedHack()
+        || classContext.forSmartPointer()) {
+        return result;
+    }
+
+    const auto moduleEntry = TypeDatabase::instance()->defaultTypeSystemType();
+    const auto &baseClasses = allBaseClasses(classContext.metaClass());
+    for (const auto &base : baseClasses) {
+        const auto te = base->typeEntry();
+        if (te->codeGeneration() == TypeEntry::GenerateCode) { // current module
+            const auto context = contextForClass(base);
+            if (context.useWrapper()) {
+                const QString header = headerFileNameForContext(context);
+                const auto type = typeSystemTypeEntry(te) == moduleEntry
+                    ? Include::LocalPath : Include::IncludePath;
+                result.append(Include(type, header));
+            }
+        }
+    }
+    return result;
+}
+
 QString ShibokenGenerator::fullPythonFunctionName(const AbstractMetaFunctionCPtr &func, bool forceFunc)
 {
     QString funcName;
@@ -319,6 +399,11 @@ QString ShibokenGenerator::fullPythonFunctionName(const AbstractMetaFunctionCPtr
     return funcName;
 }
 
+bool ShibokenGenerator::wrapperDiagnostics()
+{
+    return m_options.wrapperDiagnostics;
+}
+
 QString ShibokenGenerator::protectedEnumSurrogateName(const AbstractMetaEnum &metaEnum)
 {
     QString result = metaEnum.fullName();
@@ -354,37 +439,37 @@ QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunctionCPtr &f
 QString ShibokenGenerator::cpythonMethodDefinitionName(const AbstractMetaFunctionCPtr &func)
 {
     if (!func->ownerClass())
-        return QString();
+        return {};
     return cpythonBaseName(func->ownerClass()->typeEntry()) + u"Method_"_s
            + func->name();
 }
 
-QString ShibokenGenerator::cpythonGettersSettersDefinitionName(const AbstractMetaClass *metaClass)
+QString ShibokenGenerator::cpythonGettersSettersDefinitionName(const AbstractMetaClassCPtr &metaClass)
 {
     return cpythonBaseName(metaClass) + u"_getsetlist"_s;
 }
 
-QString ShibokenGenerator::cpythonSetattroFunctionName(const AbstractMetaClass *metaClass)
+QString ShibokenGenerator::cpythonSetattroFunctionName(const AbstractMetaClassCPtr &metaClass)
 {
     return cpythonBaseName(metaClass) + u"_setattro"_s;
 }
 
 
-QString ShibokenGenerator::cpythonGetattroFunctionName(const AbstractMetaClass *metaClass)
+QString ShibokenGenerator::cpythonGetattroFunctionName(const AbstractMetaClassCPtr &metaClass)
 {
     return cpythonBaseName(metaClass) + u"_getattro"_s;
 }
 
 QString ShibokenGenerator::cpythonGetterFunctionName(const QString &name,
-                                                     const AbstractMetaClass *enclosingClass)
+                                                     const AbstractMetaClassCPtr &enclosingClass)
 {
-    return cpythonBaseName(enclosingClass) + QStringLiteral("_get_") + name;
+    return cpythonBaseName(enclosingClass) + "_get_"_L1 + name;
 }
 
 QString ShibokenGenerator::cpythonSetterFunctionName(const QString &name,
-                                                     const AbstractMetaClass *enclosingClass)
+                                                     const AbstractMetaClassCPtr &enclosingClass)
 {
-    return cpythonBaseName(enclosingClass) + QStringLiteral("_set_") + name;
+    return cpythonBaseName(enclosingClass) + "_set_"_L1 + name;
 }
 
 QString ShibokenGenerator::cpythonGetterFunctionName(const AbstractMetaField &metaField)
@@ -398,13 +483,13 @@ QString ShibokenGenerator::cpythonSetterFunctionName(const AbstractMetaField &me
 }
 
 QString ShibokenGenerator::cpythonGetterFunctionName(const QPropertySpec &property,
-                                                     const AbstractMetaClass *metaClass)
+                                                     const AbstractMetaClassCPtr &metaClass)
 {
     return cpythonGetterFunctionName(property.name(), metaClass);
 }
 
 QString ShibokenGenerator::cpythonSetterFunctionName(const QPropertySpec &property,
-                                                     const AbstractMetaClass *metaClass)
+                                                     const AbstractMetaClassCPtr &metaClass)
 {
     return cpythonSetterFunctionName(property.name(), metaClass);
 }
@@ -439,15 +524,15 @@ QString ShibokenGenerator::cpythonFlagsName(const FlagsTypeEntryCPtr &flagsEntry
 QString ShibokenGenerator::cpythonFlagsName(const AbstractMetaEnum *metaEnum)
 {
     const auto flags = metaEnum->typeEntry()->flags();
-    return flags.isNull() ? QString{} : cpythonFlagsName(flags);
+    return flags ? cpythonFlagsName(flags) : QString{};
 }
 
-QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClass *metaClass)
+QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClassCPtr &metaClass)
 {
     return cpythonBaseName(metaClass->typeEntry()) + u"SpecialCastFunction"_s;
 }
 
-QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaClass *metaClass,
+QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaClassCPtr &metaClass,
                                               const QString &argName)
 {
     return cpythonWrapperCPtr(metaClass->typeEntry(), argName);
@@ -457,7 +542,7 @@ QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaType &metaType,
                                               const QString &argName)
 {
     if (!metaType.isWrapperType())
-        return QString();
+        return {};
     return u"reinterpret_cast< ::"_s + metaType.cppSignature()
         + u" *>(Shiboken::Conversions::cppPointer("_s + cpythonTypeNameExt(metaType)
         + u", reinterpret_cast<SbkObject *>("_s + argName + u")))"_s;
@@ -468,29 +553,30 @@ QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntryCPtr &type,
 {
     if (!type->isWrapperType())
         return QString();
-    return u"reinterpret_cast< ::"_s + type->qualifiedCppName()
+    return u"reinterpret_cast< "_s + getFullTypeName(type)
         + u" *>(Shiboken::Conversions::cppPointer("_s + cpythonTypeNameExt(type)
         + u", reinterpret_cast<SbkObject *>("_s + argName + u")))"_s;
 }
 
 void ShibokenGenerator::writeToPythonConversion(TextStream & s, const AbstractMetaType &type,
-                                                const AbstractMetaClass * /* context */,
+                                                const AbstractMetaClassCPtr & /* context */,
                                                 const QString &argumentName)
 {
     s << cpythonToPythonConversionFunction(type) << argumentName << ')';
 }
 
-void ShibokenGenerator::writeToCppConversion(TextStream &s, const AbstractMetaClass *metaClass,
+void ShibokenGenerator::writeToCppConversion(TextStream &s,
+                                             const AbstractMetaClassCPtr &metaClass,
                                              const QString &inArgName, const QString &outArgName)
 {
     s << cpythonToCppConversionFunction(metaClass) << inArgName << ", &" << outArgName << ')';
 }
 
 void ShibokenGenerator::writeToCppConversion(TextStream &s, const AbstractMetaType &type,
-                                             const AbstractMetaClass *context, const QString &inArgName,
+                                             const QString &inArgName,
                                              const QString &outArgName)
 {
-    s << cpythonToCppConversionFunction(type, context) << inArgName << ", &" << outArgName << ')';
+    s << cpythonToCppConversionFunction(type) << inArgName << ", &" << outArgName << ')';
 }
 
 bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFunctionCPtr &func,
@@ -525,11 +611,29 @@ QString ShibokenGenerator::cpythonBaseName(const AbstractMetaType &type)
     return cpythonBaseName(type.typeEntry());
 }
 
-QString ShibokenGenerator::cpythonBaseName(const AbstractMetaClass *metaClass)
+QString ShibokenGenerator::cpythonBaseName(const AbstractMetaClassCPtr &metaClass)
 {
     return cpythonBaseName(metaClass->typeEntry());
 }
 
+QString ShibokenGenerator::containerCpythonBaseName(const ContainerTypeEntryCPtr &ctype)
+{
+    switch (ctype->containerKind()) {
+    case ContainerTypeEntry::SetContainer:
+        return u"PySet"_s;
+    case ContainerTypeEntry::MapContainer:
+    case ContainerTypeEntry::MultiMapContainer:
+        return u"PyDict"_s;
+    case ContainerTypeEntry::ListContainer:
+    case ContainerTypeEntry::PairContainer:
+    case ContainerTypeEntry::SpanContainer:
+        break;
+    default:
+        Q_ASSERT(false);
+    }
+    return cPySequenceT;
+}
+
 QString ShibokenGenerator::cpythonBaseName(const TypeEntryCPtr &type)
 {
     QString baseName;
@@ -540,36 +644,19 @@ QString ShibokenGenerator::cpythonBaseName(const TypeEntryCPtr &type)
         baseName = ptype->hasTargetLangApiType()
                    ? ptype->targetLangApiName() : pythonPrimitiveTypeName(ptype->name());
     } else if (type->isEnum()) {
-        baseName = cpythonEnumName(qSharedPointerCast<const EnumTypeEntry>(type));
+        baseName = cpythonEnumName(std::static_pointer_cast<const EnumTypeEntry>(type));
     } else if (type->isFlags()) {
-        baseName = cpythonFlagsName(qSharedPointerCast<const FlagsTypeEntry>(type));
+        baseName = cpythonFlagsName(std::static_pointer_cast<const FlagsTypeEntry>(type));
     } else if (type->isContainer()) {
-        const auto ctype = qSharedPointerCast<const ContainerTypeEntry>(type);
-        switch (ctype->containerKind()) {
-            case ContainerTypeEntry::ListContainer:
-                //baseName = "PyList";
-                //break;
-            case ContainerTypeEntry::PairContainer:
-                //baseName = "PyTuple";
-                baseName = cPySequenceT();
-                break;
-            case ContainerTypeEntry::SetContainer:
-                baseName = u"PySet"_s;
-                break;
-            case ContainerTypeEntry::MapContainer:
-            case ContainerTypeEntry::MultiMapContainer:
-                baseName = u"PyDict"_s;
-                break;
-            default:
-                Q_ASSERT(false);
-        }
+        const auto ctype = std::static_pointer_cast<const ContainerTypeEntry>(type);
+        baseName = containerCpythonBaseName(ctype);
     } else {
-        baseName = cPyObjectT();
+        baseName = cPyObjectT;
     }
     return baseName.replace(u"::"_s, u"_"_s);
 }
 
-QString ShibokenGenerator::cpythonTypeName(const AbstractMetaClass *metaClass)
+QString ShibokenGenerator::cpythonTypeName(const AbstractMetaClassCPtr &metaClass)
 {
     return cpythonTypeName(metaClass->typeEntry());
 }
@@ -579,12 +666,6 @@ QString ShibokenGenerator::cpythonTypeName(const TypeEntryCPtr &type)
     return cpythonBaseName(type) + u"_TypeF()"_s;
 }
 
-QString ShibokenGenerator::cpythonTypeNameExt(const TypeEntryCPtr &type)
-{
-    return cppApiVariableName(type->targetLangPackage()) + u'['
-            + getTypeIndexVariableName(type) + u']';
-}
-
 QString ShibokenGenerator::converterObject(const AbstractMetaType &type)
 {
     if (type.isCString())
@@ -593,7 +674,7 @@ QString ShibokenGenerator::converterObject(const AbstractMetaType &type)
         return u"Shiboken::Conversions::PrimitiveTypeConverter<void *>()"_s;
     const AbstractMetaTypeList nestedArrayTypes = type.nestedArrayTypes();
     if (!nestedArrayTypes.isEmpty() && nestedArrayTypes.constLast().isCppPrimitive()) {
-        return QStringLiteral("Shiboken::Conversions::ArrayTypeConverter<")
+        return "Shiboken::Conversions::ArrayTypeConverter<"_L1
             + nestedArrayTypes.constLast().minimalSignature()
             + u">("_s + QString::number(nestedArrayTypes.size())
             + u')';
@@ -615,23 +696,20 @@ QString ShibokenGenerator::converterObject(const TypeEntryCPtr &type)
     if (type->isWrapperType())
         return QString::fromLatin1("PepType_SOTP(reinterpret_cast<PyTypeObject *>(%1))->converter")
                                   .arg(cpythonTypeNameExt(type));
-    if (type->isEnum())
+    if (type->isEnum() || type->isFlags())
         return QString::fromLatin1("PepType_SETP(reinterpret_cast<SbkEnumType *>(%1))->converter")
                                   .arg(cpythonTypeNameExt(type));
-    if (type->isFlags())
-        return QString::fromLatin1("PepType_PFTP(reinterpret_cast<PySideQFlagsType *>(%1))->converter")
-                                  .arg(cpythonTypeNameExt(type));
 
     if (type->isArray()) {
         qDebug() << "Warning: no idea how to handle the Qt5 type " << type->qualifiedCppName();
-        return QString();
+        return {};
     }
 
     /* the typedef'd primitive types case */
-    auto pte = qSharedPointerDynamicCast<const PrimitiveTypeEntry>(type);
-    if (pte.isNull()) {
+    auto pte = std::dynamic_pointer_cast<const PrimitiveTypeEntry>(type);
+    if (!pte) {
         qDebug() << "Warning: the Qt5 primitive type is unknown" << type->qualifiedCppName();
-        return QString();
+        return {};
     }
     pte = basicReferencedTypeEntry(pte);
     if (pte->isPrimitive() && !isCppPrimitive(pte) && !pte->customConversion()) {
@@ -643,13 +721,29 @@ QString ShibokenGenerator::converterObject(const TypeEntryCPtr &type)
            + u'[' + getTypeIndexVariableName(type) + u']';
 }
 
-QString ShibokenGenerator::cpythonTypeNameExt(const AbstractMetaType &type)
+QString ShibokenGenerator::cpythonTypeNameExtSet(const TypeEntryCPtr &type)
+{
+    return cppApiVariableName(type->targetLangPackage()) + u'['
+            + getTypeIndexVariableName(type) + "].type"_L1;
+}
+
+QString ShibokenGenerator::cpythonTypeNameExtSet(const AbstractMetaType &type)
 {
     return cppApiVariableName(type.typeEntry()->targetLangPackage()) + u'['
-           + getTypeIndexVariableName(type) + u']';
+           + getTypeIndexVariableName(type) + "].type"_L1;
+}
+
+QString ShibokenGenerator::cpythonTypeNameExt(const TypeEntryCPtr &type)
+{
+    return "Shiboken::Module::get("_L1 + cppApiVariableName(type->targetLangPackage())
+            + u'[' + getTypeIndexVariableName(type) + "])"_L1;
 }
 
-static inline QString unknownOperator() { return QStringLiteral("__UNKNOWN_OPERATOR__"); }
+QString ShibokenGenerator::cpythonTypeNameExt(const AbstractMetaType &type)
+{
+    return u"Shiboken::Module::get("_s + cppApiVariableName(type.typeEntry()->targetLangPackage())
+            + u'[' + getTypeIndexVariableName(type) + "])"_L1;
+}
 
 QString ShibokenGenerator::fixedCppTypeName(const TargetToNativeConversion &toNative)
 {
@@ -698,8 +792,8 @@ QString ShibokenGenerator::pythonOperatorFunctionName(const AbstractMetaFunction
 {
     QString op = Generator::pythonOperatorFunctionName(func->originalName());
     if (op.isEmpty()) {
-        qCWarning(lcShiboken).noquote().nospace() << msgUnknownOperator(func.data());
-        return unknownOperator();
+        qCWarning(lcShiboken).noquote().nospace() << msgUnknownOperator(func.get());
+        return "__UNKNOWN_OPERATOR__"_L1;
     }
     if (func->arguments().isEmpty()) {
         if (op == u"__sub__")
@@ -716,8 +810,8 @@ QString ShibokenGenerator::pythonOperatorFunctionName(const AbstractMetaFunction
 
 bool ShibokenGenerator::isNumber(const QString &cpythonApiName)
 {
-    return cpythonApiName == pyFloatT() || cpythonApiName == pyLongT()
-       || cpythonApiName == pyBoolT();
+    return cpythonApiName == pyFloatT || cpythonApiName == pyLongT
+       || cpythonApiName == pyBoolT;
 }
 
 static std::optional<TypeSystem::CPythonType>
@@ -728,7 +822,7 @@ static std::optional<TypeSystem::CPythonType>
     const auto cte = t->targetLangApiType();
     if (cte->type() != TypeEntry::PythonType)
         return {};
-    return qSharedPointerCast<const PythonTypeEntry>(cte)->cPythonType();
+    return std::static_pointer_cast<const PythonTypeEntry>(cte)->cPythonType();
 }
 
 bool ShibokenGenerator::isNumber(const TypeEntryCPtr &type)
@@ -764,7 +858,7 @@ bool ShibokenGenerator::isPyInt(const TypeEntryCPtr &type)
     if (!cPythonTypeOpt.has_value()) {
         const auto &mapping = primitiveTypesCorrespondences();
         const auto it = mapping.constFind(pte->name());
-        return it != mapping.cend() && it.value() ==  pyLongT();
+        return it != mapping.cend() && it.value() ==  pyLongT;
     }
     return cPythonTypeOpt.value() == TypeSystem::CPythonType::Integer;
 }
@@ -784,7 +878,7 @@ QString ShibokenGenerator::cpythonCheckFunction(AbstractMetaType metaType)
 {
     const auto typeEntry = metaType.typeEntry();
     if (typeEntry->isCustom()) {
-        const auto cte = qSharedPointerCast<const CustomTypeEntry>(typeEntry);
+        const auto cte = std::static_pointer_cast<const CustomTypeEntry>(typeEntry);
         if (cte->hasCheckFunction())
             return cte->checkFunction();
         throw Exception(msgUnknownCheckFunction(typeEntry));
@@ -801,7 +895,7 @@ QString ShibokenGenerator::cpythonCheckFunction(AbstractMetaType metaType)
     if (typeEntry->isContainer()) {
         QString typeCheck = u"Shiboken::Conversions::"_s;
         ContainerTypeEntry::ContainerKind type =
-            qSharedPointerCast<const ContainerTypeEntry>(typeEntry)->containerKind();
+            std::static_pointer_cast<const ContainerTypeEntry>(typeEntry)->containerKind();
         if (type == ContainerTypeEntry::ListContainer
             || type == ContainerTypeEntry::SetContainer) {
             const QString containerType = type == ContainerTypeEntry::SetContainer
@@ -852,7 +946,7 @@ QString ShibokenGenerator::cpythonCheckFunction(AbstractMetaType metaType)
 QString ShibokenGenerator::cpythonCheckFunction(TypeEntryCPtr type)
 {
     if (type->isCustom()) {
-        const auto cte = qSharedPointerCast<const CustomTypeEntry>(type);
+        const auto cte = std::static_pointer_cast<const CustomTypeEntry>(type);
         if (cte->hasCheckFunction())
             return cte->checkFunction();
         throw Exception(msgUnknownCheckFunction(type));
@@ -881,7 +975,7 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntryCPtr &typ
         QString result = u"Shiboken::Conversions::"_s;
         bool isValue = false;
         if (type->isValue()) {
-            const auto cte = qSharedPointerCast<const ComplexTypeEntry>(type);
+            const auto cte = std::static_pointer_cast<const ComplexTypeEntry>(type);
             isValue = !cte->isValueTypeWithCopyConstructorOnly();
         }
         result += isValue ? u"isPythonToCppValueConvertible"_s
@@ -893,11 +987,11 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntryCPtr &typ
               .arg(converterObject(type));
 }
 
-QString ShibokenGenerator::cpythonIsConvertibleFunction(AbstractMetaType metaType)
+QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType &metaType)
 {
     const auto typeEntry = metaType.typeEntry();
     if (typeEntry->isCustom()) {
-        const auto cte = qSharedPointerCast<const CustomTypeEntry>(typeEntry);
+        const auto cte = std::static_pointer_cast<const CustomTypeEntry>(typeEntry);
         if (cte->hasCheckFunction())
             return cte->checkFunction();
         throw Exception(msgUnknownCheckFunction(typeEntry));
@@ -910,12 +1004,14 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(AbstractMetaType metaTyp
         return result;
     }
     if (metaType.isWrapperType()) {
-        if (metaType.isPointer() || metaType.isValueTypeWithCopyConstructorOnly())
+        if (metaType.isPointer() || metaType.isValueTypeWithCopyConstructorOnly()) {
             result += u"pythonToCppPointerConversion"_s;
-        else if (metaType.referenceType() == LValueReference)
+        } else if (metaType.referenceType() == LValueReference
+                   || (metaType.referenceType() == RValueReference && typeEntry->isObject())) {
             result += u"pythonToCppReferenceConversion"_s;
-        else
+        } else {
             result += u"pythonToCppValueConversion"_s;
+        }
         result += u'(' + cpythonTypeNameExt(metaType) + u", "_s;
         return result;
     }
@@ -938,26 +1034,24 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaArgume
     return cpythonIsConvertibleFunction(metaArg.type());
 }
 
-QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClass *metaClass)
+QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClassCPtr &metaClass)
 {
     return u"Shiboken::Conversions::pythonToCppPointer("_s
         + cpythonTypeNameExt(metaClass->typeEntry()) + u", "_s;
 }
 
-QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaType &type,
-                                                          const AbstractMetaClass * /* context */)
+QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaType &type)
 {
     if (type.isWrapperType()) {
         return u"Shiboken::Conversions::pythonToCpp"_s
             + (type.isPointer() ? u"Pointer"_s : u"Copy"_s)
             + u'(' + cpythonTypeNameExt(type) + u", "_s;
     }
-    return QStringLiteral("Shiboken::Conversions::pythonToCppCopy(%1, ")
-              .arg(converterObject(type));
+    return "Shiboken::Conversions::pythonToCppCopy("_L1
+           + converterObject(type) + ", "_L1;
 }
 
-QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaType &type,
-                                                             const AbstractMetaClass * /* context */)
+QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaType &type)
 {
     if (type.isWrapperType()) {
         QString conversion;
@@ -976,12 +1070,13 @@ QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaT
             result += u'&';
         return result;
     }
-    return QStringLiteral("Shiboken::Conversions::copyToPython(%1, %2")
-              .arg(converterObject(type),
-                   (type.isCString() || type.isVoidPointer()) ? QString() : u"&"_s);
+
+    const auto indirections = type.indirections() - 1;
+    return u"Shiboken::Conversions::copyToPython("_s + converterObject(type)
+           + u", "_s + AbstractMetaType::dereferencePrefix(indirections);
 }
 
-QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaClass *metaClass)
+QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaClassCPtr &metaClass)
 {
     return cpythonToPythonConversionFunction(metaClass->typeEntry());
 }
@@ -1009,13 +1104,14 @@ QString ShibokenGenerator::argumentString(const AbstractMetaFunctionCPtr &func,
     auto type = options.testFlag(OriginalTypeDescription)
         ? argument.type() : argument.modifiedType();
 
+
     QString arg = translateType(type, func->implementingClass(), options);
 
     if (argument.isTypeModified())
         arg.replace(u'$', u'.'); // Haehh?
 
     // "int a", "int a[]"
-    const int arrayPos = arg.indexOf(u'[');
+    const auto arrayPos = arg.indexOf(u'[');
     if (arrayPos != -1)
         arg.insert(arrayPos, u' ' + argument.name());
     else
@@ -1051,6 +1147,10 @@ void ShibokenGenerator::writeFunctionArguments(TextStream &s,
                                                Options options) const
 {
     int argUsed = 0;
+    if (func->isUserAddedPythonOverride()) {
+        s << "Shiboken::GilState &gil, PyObject *" << PYTHON_OVERRIDE_VAR;
+        argUsed += 2;
+    }
     for (const auto &arg : func->arguments()) {
         if (options.testFlag(Generator::SkipRemovedArguments) && arg.isModifiedRemoved())
             continue;
@@ -1062,7 +1162,7 @@ void ShibokenGenerator::writeFunctionArguments(TextStream &s,
     }
 }
 
-GeneratorContext ShibokenGenerator::contextForClass(const AbstractMetaClass *c) const
+GeneratorContext ShibokenGenerator::contextForClass(const AbstractMetaClassCPtr &c) const
 {
     GeneratorContext result = Generator::contextForClass(c);
     if (shouldGenerateCppWrapper(c)) {
@@ -1087,6 +1187,8 @@ QString ShibokenGenerator::functionSignature(const AbstractMetaFunctionCPtr &fun
 {
     StringStream s(TextStream::Language::Cpp);
     // The actual function
+    if (!options.testFlag(Option::SkipDefaultValues) && func->isStatic()) // Declaration
+        s << "static ";
     if (func->isEmptyFunction() || func->needsReturnType())
         s << functionReturnType(func, options) << ' ';
     else
@@ -1151,7 +1253,7 @@ void ShibokenGenerator::writeFunctionCall(TextStream &s,
 ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverters() const
 {
     ExtendedConverterData extConvs;
-    for (auto metaClass : api().classes()) {
+    for (const auto &metaClass : api().classes()) {
         // Use only the classes for the current module.
         if (!shouldGenerate(metaClass->typeEntry()))
             continue;
@@ -1188,7 +1290,7 @@ static QString getArgumentsFromMethodCall(const QString &str)
     // For more information check this:
     // http://perl.plover.com/yak/regex/samples/slide083.html
     static QLatin1String funcCall("%CPPSELF.%FUNCTION_NAME");
-    int pos = str.indexOf(funcCall);
+    auto pos = str.indexOf(funcCall);
     if (pos == -1)
         return QString();
     pos = pos + funcCall.size();
@@ -1232,7 +1334,7 @@ void ShibokenGenerator::processClassCodeSnip(QString &code, const GeneratorConte
     code.replace(u"%TYPE"_s, className);
     code.replace(u"%CPPTYPE"_s, metaClass->name());
 
-    processCodeSnip(code);
+    processCodeSnip(code, context.effectiveClassName());
 }
 
 void ShibokenGenerator::processCodeSnip(QString &code) const
@@ -1250,6 +1352,15 @@ void ShibokenGenerator::processCodeSnip(QString &code) const
     replaceTypeCheckTypeSystemVariable(code);
 }
 
+void ShibokenGenerator::processCodeSnip(QString &code, const QString &context) const
+{
+    try {
+        processCodeSnip(code);
+    } catch (const std::exception &e) {
+        throw Exception(msgSnippetError(context, e.what()));
+    }
+}
+
 ShibokenGenerator::ArgumentVarReplacementList
     ShibokenGenerator::getArgumentReplacement(const AbstractMetaFunctionCPtr &func,
                                               bool usePyArgs, TypeSystem::Language language,
@@ -1270,7 +1381,7 @@ ShibokenGenerator::ArgumentVarReplacementList
             if (argRemoved && hasConversionRule)
                 argValue = arg.name() + CONV_RULE_OUT_VAR_SUFFIX;
             else if (argRemoved || (lastArg && arg.argumentIndex() > lastArg->argumentIndex()))
-                argValue = CPP_ARG_REMOVED + QString::number(i);
+                argValue = CPP_ARG_REMOVED(i);
             if (!argRemoved && argValue.isEmpty()) {
                 int argPos = i - removed;
                 AbstractMetaType type = arg.modifiedType();
@@ -1280,7 +1391,7 @@ ShibokenGenerator::ArgumentVarReplacementList
                 } else {
                     argValue = hasConversionRule
                                ? arg.name() + CONV_RULE_OUT_VAR_SUFFIX
-                               : CPP_ARG + QString::number(argPos);
+                               : CPP_ARG_N(argPos);
                     const auto generatorArg = GeneratorArgument::fromMetaType(type);
                     AbstractMetaType::applyDereference(&argValue, generatorArg.indirections);
                 }
@@ -1322,7 +1433,7 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
 
 static void replacePyArg0(TypeSystem::Language language, QString *code)
 {
-    static const QString pyArg0 = u"%PYARG_0"_s;
+    static constexpr auto pyArg0 = "%PYARG_0"_L1;
 
     if (!code->contains(pyArg0))
         return;
@@ -1361,18 +1472,18 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
     // Replace %PYARG_# variables.
     replacePyArg0(language, &code);
 
-    static const QRegularExpression pyArgsRegex(QStringLiteral("%PYARG_(\\d+)"));
+    static const QRegularExpression pyArgsRegex("%PYARG_(\\d+)"_L1);
     Q_ASSERT(pyArgsRegex.isValid());
     if (language == TypeSystem::TargetLangCode) {
         if (usePyArgs) {
             code.replace(pyArgsRegex, PYTHON_ARGS + u"[\\1-1]"_s);
         } else {
-            static const QRegularExpression pyArgsRegexCheck(QStringLiteral("%PYARG_([2-9]+)"));
+            static const QRegularExpression pyArgsRegexCheck("%PYARG_([2-9]+)"_L1);
             Q_ASSERT(pyArgsRegexCheck.isValid());
             const QRegularExpressionMatch match = pyArgsRegexCheck.match(code);
             if (match.hasMatch()) {
                 qCWarning(lcShiboken).noquote().nospace()
-                    << msgWrongIndex("%PYARG", match.captured(1), func.data());
+                    << msgWrongIndex("%PYARG", match.captured(1), func.get());
                 return;
             }
             code.replace(u"%PYARG_1"_s, PYTHON_ARG);
@@ -1380,12 +1491,12 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
     } else {
         // Replaces the simplest case of attribution to a
         // Python argument on the binding virtual method.
-        static const QRegularExpression pyArgsAttributionRegex(QStringLiteral("%PYARG_(\\d+)\\s*=[^=]\\s*([^;]+)"));
+        static const QRegularExpression pyArgsAttributionRegex("%PYARG_(\\d+)\\s*=[^=]\\s*([^;]+)"_L1);
         Q_ASSERT(pyArgsAttributionRegex.isValid());
         code.replace(pyArgsAttributionRegex, u"PyTuple_SET_ITEM("_s
-                     + PYTHON_ARGS + u", \\1-1, \\2)"_s);
+                     + PYTHON_ARGS + u".object(), \\1-1, \\2)"_s);
         code.replace(pyArgsRegex, u"PyTuple_GET_ITEM("_s
-                     + PYTHON_ARGS + u", \\1-1)"_s);
+                     + PYTHON_ARGS + u".object(), \\1-1)"_s);
     }
 
     // Replace %ARG#_TYPE variables.
@@ -1397,13 +1508,13 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
         code.replace(argTypeVar, argTypeVal);
     }
 
-    static const QRegularExpression cppArgTypeRegexCheck(QStringLiteral("%ARG(\\d+)_TYPE"));
+    static const QRegularExpression cppArgTypeRegexCheck("%ARG(\\d+)_TYPE"_L1);
     Q_ASSERT(cppArgTypeRegexCheck.isValid());
     QRegularExpressionMatchIterator rit = cppArgTypeRegexCheck.globalMatch(code);
     while (rit.hasNext()) {
         QRegularExpressionMatch match = rit.next();
         qCWarning(lcShiboken).noquote().nospace()
-            << msgWrongIndex("%ARG#_TYPE", match.captured(1), func.data());
+            << msgWrongIndex("%ARG#_TYPE", match.captured(1), func.get());
     }
 
     // Replace template variable for return variable name.
@@ -1489,7 +1600,7 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
 
     QStringList args;
     for (const ArgumentVarReplacementPair &pair : argReplacements) {
-        if (pair.second.startsWith(CPP_ARG_REMOVED))
+        if (pair.second.startsWith(CPP_ARG_REMOVED_PREFIX))
             continue;
         args << pair.second;
     }
@@ -1539,8 +1650,8 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
 
         if (isProtected) {
             code.replace(u"%TYPE::%FUNCTION_NAME"_s,
-                         QStringLiteral("%1::%2_protected")
-                         .arg(wrapperName(func->ownerClass()), func->originalName()));
+                         wrapperName(func->ownerClass()) + "::"_L1
+                                     + func->originalName() + "_protected"_L1);
             code.replace(u"%FUNCTION_NAME"_s,
                          func->originalName() + u"_protected"_s);
         }
@@ -1554,7 +1665,7 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
 
     replaceTemplateVariables(code, func);
 
-    processCodeSnip(code);
+    processCodeSnip(code, func->classQualifiedSignature());
     s << "// Begin code injection\n" << code << "// End of code injection\n\n";
 }
 
@@ -1562,7 +1673,7 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
 // and false if it is a variable.
 static bool isVariable(const QString &code)
 {
-    static const QRegularExpression expr(QStringLiteral("^\\s*\\*?\\s*[A-Za-z_][A-Za-z_0-9.]*\\s*(?:\\[[^\\[]+\\])*$"));
+    static const QRegularExpression expr("^\\s*\\*?\\s*[A-Za-z_][A-Za-z_0-9.]*\\s*(?:\\[[^\\[]+\\])*$"_L1);
     Q_ASSERT(expr.isValid());
     return expr.match(code.trimmed()).hasMatch();
 }
@@ -1623,7 +1734,7 @@ const QHash<int, QString> &ShibokenGenerator::typeSystemConvName()
     return result;
 }
 
-using StringPair = QPair<QString, QString>;
+using StringPair = std::pair<QString, QString>;
 
 void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable,
                                                            QString &code) const
@@ -1658,9 +1769,6 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
                 varType = miniNormalizer(varType);
                 QString varName = list.at(1).trimmed();
                 if (!varType.isEmpty()) {
-                    const QString conversionSignature = conversionType.cppSignature();
-                    if (varType != u"auto" && varType != conversionSignature)
-                        throw Exception(msgConversionTypesDiffer(varType, conversionSignature));
                     c << getFullTypeName(conversionType) << ' ' << varName
                         << minimalConstructorExpression(api(), conversionType) << ";\n";
                 }
@@ -1677,7 +1785,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
             case TypeSystemCheckFunction:
                 conversion = cpythonCheckFunction(conversionType);
                 if (conversionType.typeEntry()->isPrimitive()
-                    && (conversionType.typeEntry()->name() == cPyObjectT()
+                    && (conversionType.typeEntry()->name() == cPyObjectT
                         || !conversion.endsWith(u' '))) {
                     conversion += u'(';
                     break;
@@ -1708,7 +1816,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
                 }
             }
         }
-        replacements.append(qMakePair(conversionString, conversion));
+        replacements.append(std::make_pair(conversionString, conversion));
     }
     for (const StringPair &rep : std::as_const(replacements))
         code.replace(rep.first, rep.second);
@@ -1735,12 +1843,13 @@ bool ShibokenGenerator::injectedCodeCallsCppFunction(const GeneratorContext &con
     return func->injectedCodeContains(wrappedCtorCall);
 }
 
-bool ShibokenGenerator::useOverrideCaching(const AbstractMetaClass *metaClass)
+bool ShibokenGenerator::useOverrideCaching(const AbstractMetaClassCPtr &metaClass)
 {
     return metaClass->isPolymorphic();
 }
 
-ShibokenGenerator::AttroCheck ShibokenGenerator::checkAttroFunctionNeeds(const AbstractMetaClass *metaClass) const
+ShibokenGenerator::AttroCheck ShibokenGenerator::checkAttroFunctionNeeds(
+    const AbstractMetaClassCPtr &metaClass)
 {
     AttroCheck result;
     if (metaClass->typeEntry()->isSmartPointer()) {
@@ -1752,7 +1861,7 @@ ShibokenGenerator::AttroCheck ShibokenGenerator::checkAttroFunctionNeeds(const A
                                           FunctionQueryOption::GetAttroFunction)) {
             result |= AttroCheckFlag::GetattroUser;
         }
-        if (usePySideExtensions() && metaClass->qualifiedCppName() == qObjectT())
+        if (usePySideExtensions() && metaClass->qualifiedCppName() == qObjectT)
             result |= AttroCheckFlag::SetattroQObject;
         if (useOverrideCaching(metaClass))
             result |= AttroCheckFlag::SetattroMethodOverride;
@@ -1764,14 +1873,14 @@ ShibokenGenerator::AttroCheck ShibokenGenerator::checkAttroFunctionNeeds(const A
         // QObject, the property code needs to be generated, too.
         if ((result & AttroCheckFlag::SetattroMask) != 0
             && !result.testFlag(AttroCheckFlag::SetattroQObject)
-            && metaClass->isQObject()) {
+            && isQObject(metaClass)) {
             result |= AttroCheckFlag::SetattroQObject;
         }
     }
     return result;
 }
 
-bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClass *metaClass)
+bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClassCPtr &metaClass)
 {
     if (!metaClass)
         return false;
@@ -1797,7 +1906,7 @@ bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClass *
 }
 
 AbstractMetaFunctionCList
-    ShibokenGenerator::getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass)
+    ShibokenGenerator::getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClassCPtr &metaClass)
 {
     AbstractMetaFunctionCList methods;
     if (metaClass) {
@@ -1821,7 +1930,8 @@ AbstractMetaFunctionCList
     return methods;
 }
 
-const AbstractMetaClass *ShibokenGenerator::getMultipleInheritingClass(const AbstractMetaClass *metaClass)
+AbstractMetaClassCPtr
+    ShibokenGenerator::getMultipleInheritingClass(const AbstractMetaClassCPtr &metaClass)
 {
     if (!metaClass || metaClass->baseClassNames().isEmpty())
         return nullptr;
@@ -1832,20 +1942,20 @@ const AbstractMetaClass *ShibokenGenerator::getMultipleInheritingClass(const Abs
 
 QString ShibokenGenerator::getModuleHeaderFileBaseName(const QString &moduleName)
 {
-    return moduleCppPrefix(moduleName).toLower() + QStringLiteral("_python");
+    return moduleCppPrefix(moduleName).toLower() + "_python"_L1;
 }
 
 QString ShibokenGenerator::getModuleHeaderFileName(const QString &moduleName)
 {
-    return getModuleHeaderFileBaseName(moduleName) + QStringLiteral(".h");
+    return getModuleHeaderFileBaseName(moduleName) + ".h"_L1;
 }
 
 QString ShibokenGenerator::getPrivateModuleHeaderFileName(const QString &moduleName)
 {
-    return getModuleHeaderFileBaseName(moduleName) + QStringLiteral("_p.h");
+    return getModuleHeaderFileBaseName(moduleName) + "_p.h"_L1;
 }
 
-IncludeGroupList ShibokenGenerator::classIncludes(const AbstractMetaClass *metaClass) const
+IncludeGroupList ShibokenGenerator::classIncludes(const AbstractMetaClassCPtr &metaClass) const
 {
     IncludeGroupList result;
     const auto typeEntry = metaClass->typeEntry();
@@ -1859,9 +1969,9 @@ IncludeGroupList ShibokenGenerator::classIncludes(const AbstractMetaClass *metaC
 
     result.append({u"Argument includes"_s, typeEntry->argumentIncludes()});
     const auto implicitConvs = implicitConversions(typeEntry);
-    for (auto &f : implicitConvs) {
+    for (const auto &f : implicitConvs) {
         if (f->isConversionOperator()) {
-            auto *source = f->ownerClass();
+            const auto source = f->ownerClass();
             Q_ASSERT(source);
             result.back().append(source->typeEntry()->include());
         }
@@ -1917,29 +2027,47 @@ ShibokenGenerator::FunctionGroups ShibokenGenerator::getGlobalFunctionGroups() c
 {
     FunctionGroups results;
     insertIntoFunctionGroups(api().globalFunctions(), &results);
-    for (auto nsp : invisibleTopNamespaces())
+    for (const auto &nsp : invisibleTopNamespaces())
         insertIntoFunctionGroups(nsp->functions(), &results);
     return results;
 }
 
-const GeneratorClassInfoCacheEntry &ShibokenGenerator::getGeneratorClassInfo(const AbstractMetaClass *scope)
+const GeneratorClassInfoCacheEntry &
+    ShibokenGenerator::getGeneratorClassInfo(const AbstractMetaClassCPtr &scope)
 {
     auto cache = generatorClassInfoCache();
     auto it = cache->find(scope);
     if (it == cache->end()) {
         it = cache->insert(scope, {});
-        it.value().functionGroups = getFunctionGroupsImpl(scope);
-        it.value().needsGetattroFunction = classNeedsGetattroFunctionImpl(scope);
+        auto &entry = it.value();
+        entry.functionGroups = getFunctionGroupsImpl(scope);
+        entry.needsGetattroFunction = classNeedsGetattroFunctionImpl(scope);
+        entry.numberProtocolOperators = getNumberProtocolOperators(scope);
+        entry.boolCastFunctionO = getBoolCast(scope);
     }
     return it.value();
 }
 
-ShibokenGenerator::FunctionGroups ShibokenGenerator::getFunctionGroups(const AbstractMetaClass *scope)
+ShibokenGenerator::FunctionGroups
+    ShibokenGenerator::getFunctionGroups(const AbstractMetaClassCPtr &scope)
 {
     Q_ASSERT(scope);
     return getGeneratorClassInfo(scope).functionGroups;
 }
 
+QList<AbstractMetaFunctionCList>
+    ShibokenGenerator::numberProtocolOperators(const AbstractMetaClassCPtr &scope)
+{
+    Q_ASSERT(scope);
+    return getGeneratorClassInfo(scope).numberProtocolOperators;
+}
+
+BoolCastFunctionOptional ShibokenGenerator::boolCast(const AbstractMetaClassCPtr &scope)
+{
+    Q_ASSERT(scope);
+    return getGeneratorClassInfo(scope).boolCastFunctionO;
+}
+
 // Use non-const overloads only, for example, "foo()" and "foo()const"
 // the second is removed.
 static void removeConstOverloads(AbstractMetaFunctionCList *overloads)
@@ -1948,7 +2076,7 @@ static void removeConstOverloads(AbstractMetaFunctionCList *overloads)
         const auto &f = overloads->at(i);
         if (f->isConstant()) {
             for (qsizetype c = 0, size = overloads->size(); c < size; ++c) {
-                if (f->isConstOverloadOf(overloads->at(c).data())) {
+                if (f->isConstOverloadOf(overloads->at(c).get())) {
                     overloads->removeAt(i);
                     break;
                 }
@@ -1957,7 +2085,8 @@ static void removeConstOverloads(AbstractMetaFunctionCList *overloads)
     }
 }
 
-ShibokenGenerator::FunctionGroups ShibokenGenerator::getFunctionGroupsImpl(const AbstractMetaClass *scope)
+ShibokenGenerator::FunctionGroups
+    ShibokenGenerator::getFunctionGroupsImpl(const AbstractMetaClassCPtr &scope)
 {
     AbstractMetaFunctionCList lst = scope->functions();
     scope->getFunctionsFromInvisibleNamespacesToBeGenerated(&lst);
@@ -1988,13 +2117,156 @@ ShibokenGenerator::FunctionGroups ShibokenGenerator::getFunctionGroupsImpl(const
     return results;
 }
 
+static bool removeNumberProtocolOperator(const AbstractMetaFunctionCPtr &f)
+{
+    return !f->generateBinding()
+        || (f->ownerClass() != f->implementingClass() && !f->isAbstract());
+}
+
+QList<AbstractMetaFunctionCList>
+    ShibokenGenerator::getNumberProtocolOperators(const AbstractMetaClassCPtr &metaClass)
+{
+    QList<AbstractMetaFunctionCList> result;
+    if (metaClass->isNamespace())
+        return result;
+    result = filterGroupedOperatorFunctions(
+            metaClass,
+            OperatorQueryOption::ArithmeticOp
+                | OperatorQueryOption::IncDecrementOp
+                | OperatorQueryOption::LogicalOp
+                | OperatorQueryOption::BitwiseOp
+                | OperatorQueryOption::ConversionOp);
+
+    for (auto i = result.size() - 1; i >= 0; --i) {
+        AbstractMetaFunctionCList &l = result[i];
+        auto rend = std::remove_if(l.begin(), l.end(), removeNumberProtocolOperator);
+        l.erase(rend, l.end());
+        if (l.isEmpty())
+            result.removeAt(i);
+    }
+
+    return result;
+}
+
+BoolCastFunctionOptional
+ShibokenGenerator::getBoolCast(const AbstractMetaClassCPtr &metaClass)
+{
+    if (metaClass->isNamespace())
+        return std::nullopt;
+
+    const auto te = metaClass->typeEntry();
+    if (te->isSmartPointer()) {
+        auto ste = std::static_pointer_cast<const SmartPointerTypeEntry>(te);
+
+        auto valueCheckMethod = ste->valueCheckMethod();
+        if (!valueCheckMethod.isEmpty()) {
+            const auto func = metaClass->findFunction(valueCheckMethod);
+            if (!func)
+                throw Exception(msgMethodNotFound(metaClass, valueCheckMethod));
+            return BoolCastFunction{func, false};
+        }
+
+        auto nullCheckMethod = ste->nullCheckMethod();
+        if (!nullCheckMethod.isEmpty()) {
+            const auto func = metaClass->findFunction(nullCheckMethod);
+            if (!func)
+                throw Exception(msgMethodNotFound(metaClass, nullCheckMethod));
+            return BoolCastFunction{func, true};
+        }
+    }
+
+    auto mode = te->operatorBoolMode();
+    if (useOperatorBoolAsNbBool()
+            ? mode != TypeSystem::BoolCast::Disabled : mode == TypeSystem::BoolCast::Enabled) {
+        const auto func = metaClass->findOperatorBool();
+        if (func)
+            return BoolCastFunction{func, false};
+    }
+
+    mode = te->isNullMode();
+    if (useIsNullAsNbBool()
+            ? mode != TypeSystem::BoolCast::Disabled : mode == TypeSystem::BoolCast::Enabled) {
+        const auto func = metaClass->findQtIsNullMethod();
+        if (func)
+            return BoolCastFunction{func, true};
+    }
+    return std::nullopt;
+}
+
+static bool isInplaceAdd(const AbstractMetaFunctionCPtr &func)
+{
+        return func->name() == u"operator+=";
+}
+
+static bool isIncrementOperator(const AbstractMetaFunctionCPtr &func)
+{
+        return func->functionType() == AbstractMetaFunction::IncrementOperator;
+}
+
+static bool isDecrementOperator(const AbstractMetaFunctionCPtr &func)
+{
+        return func->functionType() == AbstractMetaFunction::DecrementOperator;
+}
+
+// Filter predicate for operator functions
+static bool skipOperatorFunc(const AbstractMetaFunctionCPtr &func)
+{
+        if (func->isModifiedRemoved() || func->usesRValueReferences())
+            return true;
+        const auto &name = func->name();
+        return name == u"operator[]" || name == u"operator->" || name == u"operator!"
+               || name == u"operator/="; // __idiv__ is not needed in Python3
+}
+
+QList<AbstractMetaFunctionCList>
+ShibokenGenerator::filterGroupedOperatorFunctions(const AbstractMetaClassCPtr &metaClass,
+                                                  OperatorQueryOptions query)
+{
+    // ( func_name, num_args ) => func_list
+    QMap<std::pair<QString, int>, AbstractMetaFunctionCList> results;
+    auto funcs = metaClass->operatorOverloads(query);
+    auto end = std::remove_if(funcs.begin(), funcs.end(), skipOperatorFunc);
+    funcs.erase(end, funcs.end());
+    // If we have operator+=, we remove the operator++/-- which would
+    // otherwise be used for emulating __iadd__, __isub__.
+    if (std::any_of(funcs.cbegin(), funcs.cend(), isInplaceAdd)) {
+        end = std::remove_if(funcs.begin(), funcs.end(),
+                             [] (const AbstractMetaFunctionCPtr &func) {
+                                 return func->isIncDecrementOperator();
+                             });
+        funcs.erase(end, funcs.end());
+    } else {
+        // If both prefix/postfix ++/-- are present, remove one
+        if (std::count_if(funcs.begin(), funcs.end(), isIncrementOperator) > 1)
+            funcs.erase(std::find_if(funcs.begin(), funcs.end(), isIncrementOperator));
+        if (std::count_if(funcs.begin(), funcs.end(), isDecrementOperator) > 1)
+            funcs.erase(std::find_if(funcs.begin(), funcs.end(), isDecrementOperator));
+    }
+    for (const auto &func : funcs) {
+        int args;
+        if (func->isComparisonOperator()) {
+            args = -1;
+        } else {
+            args = func->arguments().size();
+        }
+        auto op = std::make_pair(func->name(), args);
+        results[op].append(func);
+    }
+    QList<AbstractMetaFunctionCList> result;
+    result.reserve(results.size());
+    for (auto it = results.cbegin(), end = results.cend(); it != end; ++it)
+        result.append(it.value());
+    return result;
+}
+
 static bool hidesBaseClassFunctions(const AbstractMetaFunctionCPtr &f)
 {
-    return 0 == (f->attributes()
-                 & (AbstractMetaFunction::OverriddenCppMethod | AbstractMetaFunction::FinalCppMethod));
+    auto attributes = f->cppAttributes();
+    return !attributes.testFlag(FunctionAttribute::Override)
+        && !attributes.testFlag(FunctionAttribute::Final);
 }
 
-void ShibokenGenerator::getInheritedOverloads(const AbstractMetaClass *scope,
+void ShibokenGenerator::getInheritedOverloads(const AbstractMetaClassCPtr &scope,
                                              AbstractMetaFunctionCList *overloads)
 {
     if (overloads->isEmpty() || scope->isNamespace() || scope->baseClasses().isEmpty())
@@ -2020,7 +2292,8 @@ void ShibokenGenerator::getInheritedOverloads(const AbstractMetaClass *scope,
 
     AbstractMetaFunctionCList baseCandidates;
 
-    auto basePredicate = [&functionName, &seenSignatures, &baseCandidates](const AbstractMetaClass *b) {
+    auto basePredicate = [&functionName, &seenSignatures, &baseCandidates]
+                         (const AbstractMetaClassCPtr &b) {
         for (const auto &f : b->functions()) {
             if (f->generateBinding() && f->name() == functionName) {
                 const QString signature = f->minimalSignature();
@@ -2033,7 +2306,7 @@ void ShibokenGenerator::getInheritedOverloads(const AbstractMetaClass *scope,
         return false; // Keep going
     };
 
-    for (const auto *baseClass : scope->baseClasses())
+    for (const auto &baseClass : scope->baseClasses())
         recurseClassHierarchy(baseClass, basePredicate);
 
     // Remove the ones that are not made visible with using declarations
@@ -2063,92 +2336,108 @@ void ShibokenGenerator::getInheritedOverloads(const AbstractMetaClass *scope,
     }
 }
 
-Generator::OptionDescriptions ShibokenGenerator::options() const
+QList<OptionDescription> ShibokenGenerator::options()
 {
-    auto result = Generator::options();
-    result.append({
-        {QLatin1StringView(DISABLE_VERBOSE_ERROR_MESSAGES),
+    return {
+        {DISABLE_VERBOSE_ERROR_MESSAGES,
          u"Disable verbose error messages. Turn the python code hard to debug\n"
           "but safe few kB on the generated bindings."_s},
-        {QLatin1StringView(PARENT_CTOR_HEURISTIC),
+        {PARENT_CTOR_HEURISTIC,
          u"Enable heuristics to detect parent relationship on constructors."_s},
-        {QLatin1StringView(RETURN_VALUE_HEURISTIC),
+        {RETURN_VALUE_HEURISTIC,
          u"Enable heuristics to detect parent relationship on return values\n"
           "(USE WITH CAUTION!)"_s},
-        {QLatin1StringView(USE_ISNULL_AS_NB_NONZERO),
+        {USE_ISNULL_AS_NB_BOOL,
          u"If a class have an isNull() const method, it will be used to compute\n"
           "the value of boolean casts"_s},
-        {QLatin1StringView(LEAN_HEADERS),
+        {LEAN_HEADERS,
          u"Forward declare classes in module headers"_s},
-        {QLatin1StringView(USE_OPERATOR_BOOL_AS_NB_NONZERO),
+        {USE_OPERATOR_BOOL_AS_NB_BOOL,
          u"If a class has an operator bool, it will be used to compute\n"
           "the value of boolean casts"_s},
-        {QLatin1StringView(NO_IMPLICIT_CONVERSIONS),
+        {NO_IMPLICIT_CONVERSIONS,
          u"Do not generate implicit_conversions for function arguments."_s},
-        {QLatin1StringView(WRAPPER_DIAGNOSTICS),
+        {WRAPPER_DIAGNOSTICS,
          u"Generate diagnostic code around wrappers"_s}
-    });
-    return result;
+    };
 }
 
-bool ShibokenGenerator::handleOption(const QString &key, const QString &value)
+class ShibokenGeneratorOptionsParser : public OptionsParser
 {
-    if (Generator::handleOption(key, value))
-        return true;
-    if (key == QLatin1StringView(PARENT_CTOR_HEURISTIC))
-        return (m_useCtorHeuristic = true);
-    if (key == QLatin1StringView(RETURN_VALUE_HEURISTIC))
-        return (m_userReturnValueHeuristic = true);
-    if (key == QLatin1StringView(DISABLE_VERBOSE_ERROR_MESSAGES))
-        return (m_verboseErrorMessagesDisabled = true);
-    if (key == QLatin1StringView(USE_ISNULL_AS_NB_NONZERO))
-        return (m_useIsNullAsNbNonZero = true);
-    if (key == QLatin1StringView(LEAN_HEADERS))
-        return (m_leanHeaders= true);
-    if (key == QLatin1StringView(USE_OPERATOR_BOOL_AS_NB_NONZERO))
-        return (m_useOperatorBoolAsNbNonZero = true);
-    if (key == QLatin1StringView(NO_IMPLICIT_CONVERSIONS)) {
-        return m_generateImplicitConversions = false;
+public:
+    explicit ShibokenGeneratorOptionsParser(ShibokenGeneratorOptions *o) : m_options(o) {}
+
+    bool handleBoolOption(const QString & key, OptionSource source) override;
+
+private:
+    ShibokenGeneratorOptions *m_options;
+};
+
+bool ShibokenGeneratorOptionsParser::handleBoolOption(const QString &key, OptionSource source)
+{
+    if (source == OptionSource::CommandLineSingleDash)
+        return false;
+    if (key == PARENT_CTOR_HEURISTIC)
+        return (m_options->useCtorHeuristic = true);
+    if (key == RETURN_VALUE_HEURISTIC)
+        return (m_options->userReturnValueHeuristic = true);
+    if (key == DISABLE_VERBOSE_ERROR_MESSAGES)
+        return (m_options->verboseErrorMessagesDisabled = true);
+    if (key == USE_ISNULL_AS_NB_BOOL || key == USE_ISNULL_AS_NB_NONZERO) {
+        return (m_options->useIsNullAsNbBool = true);
+    }
+    if (key == LEAN_HEADERS)
+        return (m_options->leanHeaders= true);
+    if (key == USE_OPERATOR_BOOL_AS_NB_BOOL || key == USE_OPERATOR_BOOL_AS_NB_NONZERO) {
+        return (m_options->useOperatorBoolAsNbBool = true);
+    }
+    if (key == NO_IMPLICIT_CONVERSIONS) {
+        m_options->generateImplicitConversions = false;
         return true;
     }
-    if (key == QLatin1StringView(WRAPPER_DIAGNOSTICS))
-        return (m_wrapperDiagnostics = true);
+    if (key == WRAPPER_DIAGNOSTICS)
+        return (m_options->wrapperDiagnostics = true);
     return false;
 }
 
+std::shared_ptr<OptionsParser> ShibokenGenerator::createOptionsParser()
+{
+    return std::make_shared<ShibokenGeneratorOptionsParser>(&m_options);
+}
+
 bool ShibokenGenerator::doSetup()
 {
     return true;
 }
 
-bool ShibokenGenerator::useCtorHeuristic() const
+bool ShibokenGenerator::useCtorHeuristic()
 {
-    return m_useCtorHeuristic;
+    return m_options.useCtorHeuristic;
 }
 
-bool ShibokenGenerator::useReturnValueHeuristic() const
+bool ShibokenGenerator::useReturnValueHeuristic()
 {
-    return m_userReturnValueHeuristic;
+    return m_options.userReturnValueHeuristic;
 }
 
-bool ShibokenGenerator::useIsNullAsNbNonZero() const
+bool ShibokenGenerator::useIsNullAsNbBool()
 {
-    return m_useIsNullAsNbNonZero;
+    return m_options.useIsNullAsNbBool;
 }
 
-bool ShibokenGenerator::leanHeaders() const
+bool ShibokenGenerator::leanHeaders()
 {
-    return m_leanHeaders;
+    return m_options.leanHeaders;
 }
 
-bool ShibokenGenerator::useOperatorBoolAsNbNonZero() const
+bool ShibokenGenerator::useOperatorBoolAsNbBool()
 {
-    return m_useOperatorBoolAsNbNonZero;
+    return m_options.useOperatorBoolAsNbBool;
 }
 
-bool ShibokenGenerator::generateImplicitConversions() const
+bool ShibokenGenerator::generateImplicitConversions()
 {
-    return m_generateImplicitConversions;
+    return m_options.generateImplicitConversions;
 }
 
 QString ShibokenGenerator::moduleCppPrefix(const QString &moduleName)
@@ -2158,19 +2447,24 @@ QString ShibokenGenerator::moduleCppPrefix(const QString &moduleName)
     return result;
 }
 
+QString ShibokenGenerator::cppApiVariableNameOld(const QString &moduleName)
+{
+    return "Sbk"_L1 + moduleCppPrefix(moduleName) + "Types"_L1;
+}
+
 QString ShibokenGenerator::cppApiVariableName(const QString &moduleName)
 {
-    return u"Sbk"_s + moduleCppPrefix(moduleName) + u"Types"_s;
+    return "Sbk"_L1 + moduleCppPrefix(moduleName) + "TypeStructs"_L1;
 }
 
 QString ShibokenGenerator::pythonModuleObjectName(const QString &moduleName)
 {
-    return u"Sbk"_s + moduleCppPrefix(moduleName) + u"ModuleObject"_s;
+    return "Sbk"_L1 + moduleCppPrefix(moduleName) + "ModuleObject"_L1;
 }
 
 QString ShibokenGenerator::convertersVariableName(const QString &moduleName)
 {
-    QString result = cppApiVariableName(moduleName);
+    QString result = cppApiVariableNameOld(moduleName);
     result.chop(1);
     result.append(u"Converters"_s);
     return result;
@@ -2178,11 +2472,11 @@ QString ShibokenGenerator::convertersVariableName(const QString &moduleName)
 
 static QString processInstantiationsVariableName(const AbstractMetaType &type)
 {
-    QString res = u'_' + _fixedCppTypeName(type.typeEntry()->qualifiedCppName()).toUpper();
+    QString res = u'_' + _fixedCppTypeName(type.typeEntry()->qualifiedCppName());
     for (const auto &instantiation : type.instantiations()) {
         res += instantiation.isContainer()
                ? processInstantiationsVariableName(instantiation)
-               : u'_' + _fixedCppTypeName(instantiation.cppSignature()).toUpper();
+               : u'_' + _fixedCppTypeName(instantiation.cppSignature());
     }
     return res;
 }
@@ -2191,22 +2485,23 @@ static void appendIndexSuffix(QString *s)
 {
     if (!s->endsWith(u'_'))
         s->append(u'_');
-    s->append(QStringLiteral("IDX"));
+    s->append("IDX"_L1);
 }
 
-QString ShibokenGenerator::getTypeAlternateTemplateIndexVariableName(const AbstractMetaClass *metaClass)
+QString
+    ShibokenGenerator::getTypeAlternateTemplateIndexVariableName(const AbstractMetaClassCPtr &metaClass)
 {
-    const AbstractMetaClass *templateBaseClass = metaClass->templateBaseClass();
+    const auto templateBaseClass = metaClass->templateBaseClass();
     Q_ASSERT(templateBaseClass);
     QString result = u"SBK_"_s
-        + _fixedCppTypeName(templateBaseClass->typeEntry()->qualifiedCppName()).toUpper();
+        + _fixedCppTypeName(templateBaseClass->typeEntry()->qualifiedCppName());
     for (const auto &instantiation : metaClass->templateBaseClassInstantiations())
         result += processInstantiationsVariableName(instantiation);
     appendIndexSuffix(&result);
     return result;
 }
 
-QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass *metaClass)
+QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClassCPtr &metaClass)
 {
     return getTypeIndexVariableName(metaClass->typeEntry());
 }
@@ -2221,7 +2516,7 @@ QString ShibokenGenerator::getTypeIndexVariableName(TypeEntryCPtr type)
         const int dot = package.lastIndexOf(u'.');
         result += QStringView{package}.right(package.size() - (dot + 1));
     }
-    result += _fixedCppTypeName(type->qualifiedCppName()).toUpper();
+    result += _fixedCppTypeName(type->qualifiedCppName());
     appendIndexSuffix(&result);
     return result;
 }
@@ -2229,15 +2524,49 @@ QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaType &type
 {
     QString result = u"SBK"_s;
     if (type.typeEntry()->isContainer())
-        result += u'_' + moduleName().toUpper();
+        result += u'_' + moduleName();
     result += processInstantiationsVariableName(type);
     appendIndexSuffix(&result);
     return result;
 }
 
-bool ShibokenGenerator::verboseErrorMessagesDisabled() const
+void collectfromTypeEntry(TypeEntryCPtr entry, QStringList &typeNames)
+{
+    if (entry->shouldGenerate()) {
+        typeNames[entry->sbkIndex()] = entry->qualifiedTargetLangName();
+        if (entry->isEnum()) {
+            auto ete = std::static_pointer_cast<const EnumTypeEntry>(entry);
+            if (ete->flags()) {
+                auto entry = ete->flags();
+                typeNames[entry->sbkIndex()] = entry->qualifiedTargetLangName();
+            }
+        }
+    }
+}
+
+void ShibokenGenerator::collectFullTypeNamesArray(QStringList &typeNames)
+{
+    for (const auto &metaClass : api().classes()) {
+        collectfromTypeEntry(metaClass->typeEntry(), typeNames);
+
+        for (const AbstractMetaEnum &metaEnum : metaClass->enums())
+            collectfromTypeEntry(metaEnum.typeEntry(), typeNames);
+
+        int smartPointerCountIndex = getMaxTypeIndex();
+        for (const auto &smp : api().instantiatedSmartPointers()) {
+            auto entry = smp.type.typeEntry();
+            typeNames[smartPointerCountIndex] =
+                smp.specialized->typeEntry()->qualifiedTargetLangName();
+            ++smartPointerCountIndex;
+        }
+    }
+    for (const AbstractMetaEnum &metaEnum : api().globalEnums())
+        collectfromTypeEntry(metaEnum.typeEntry(), typeNames);
+}
+
+bool ShibokenGenerator::verboseErrorMessagesDisabled()
 {
-    return m_verboseErrorMessagesDisabled;
+    return m_options.verboseErrorMessagesDisabled;
 }
 
 bool ShibokenGenerator::pythonFunctionWrapperUsesListOfArguments(const AbstractMetaFunctionCPtr &func) const
@@ -2290,7 +2619,7 @@ QString ShibokenGenerator::pythonArgsAt(int i)
 void ShibokenGenerator::replaceTemplateVariables(QString &code,
                                                  const AbstractMetaFunctionCPtr &func) const
 {
-    const AbstractMetaClass *cpp_class = func->ownerClass();
+    const auto cpp_class = func->ownerClass();
     if (cpp_class)
         code.replace(u"%TYPE"_s, cpp_class->name());
 
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.h b/sources/shiboken6/generator/shiboken/shibokengenerator.h
index d0b1158c6..22ee73fa2 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.h
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.h
@@ -7,12 +7,14 @@
 #include <generator.h>
 
 #include "customconversion_typedefs.h"
+#include "abstractmetalang_enums.h"
 #include "typesystem_typedefs.h"
 #include "typesystem_enums.h"
 
 #include <QtCore/QRegularExpression>
 
 #include <array>
+#include <optional>
 
 class EnumTypeEntry;
 class FlagsTypeEntry;
@@ -23,8 +25,18 @@ class OverloadData;
 class TargetToNativeConversion;
 struct GeneratorClassInfoCacheEntry;
 struct IncludeGroup;
+struct ShibokenGeneratorOptions;
 
-QT_FORWARD_DECLARE_CLASS(TextStream)
+class TextStream;
+
+// Function to be used for implementing nb_bool
+struct BoolCastFunction
+{
+    AbstractMetaFunctionCPtr function;
+    bool invert = false; // Function is "isNull()", (invert result).
+};
+
+using BoolCastFunctionOptional = std::optional<BoolCastFunction>;
 
 /**
  * Abstract generator that contains common methods used in CppGenerator and HeaderGenerator.
@@ -32,6 +44,8 @@ QT_FORWARD_DECLARE_CLASS(TextStream)
 class ShibokenGenerator : public Generator
 {
 public:
+    Q_DISABLE_COPY_MOVE(ShibokenGenerator)
+
     /// Besides the actual bindings (see AbstractMetaFunction::generateBinding(),
     /// some functions need to be generated into the wrapper class
     /// (virtual method/avoid protected hack expose).
@@ -75,6 +89,9 @@ public:
 
     const char *name() const override { return "Shiboken"; }
 
+    static QList<OptionDescription> options();
+    static std::shared_ptr<OptionsParser> createOptionsParser();
+
     static QString minimalConstructorExpression(const ApiExtractorResult &api,
                                                 const AbstractMetaType &type);
     static QString minimalConstructorExpression(const ApiExtractorResult &api,
@@ -83,7 +100,7 @@ public:
 protected:
     bool doSetup() override;
 
-    GeneratorContext contextForClass(const AbstractMetaClass *c) const override;
+    GeneratorContext contextForClass(const AbstractMetaClassCPtr &c) const override;
 
     /**
      *   Returns a map with all functions grouped, the function name is used as key.
@@ -91,7 +108,12 @@ protected:
      *   \param scope Where to search for functions, null means all global functions.
      */
     FunctionGroups getGlobalFunctionGroups() const;
-    static FunctionGroups getFunctionGroups(const AbstractMetaClass *scope);
+    static FunctionGroups getFunctionGroups(const AbstractMetaClassCPtr &scope);
+
+    static QList<AbstractMetaFunctionCList>
+        numberProtocolOperators(const AbstractMetaClassCPtr &scope);
+
+    static BoolCastFunctionOptional boolCast(const AbstractMetaClassCPtr &scope);
 
     /**
      *   Returns all different inherited overloads of func, and includes func as well.
@@ -123,6 +145,7 @@ protected:
 
     /// Replaces variables for the user's custom code at global or class level.
     void processCodeSnip(QString &code) const;
+    void processCodeSnip(QString &code, const QString &context) const;
     void processClassCodeSnip(QString &code, const GeneratorContext &context) const;
 
     /**
@@ -148,53 +171,65 @@ protected:
                               int arg_count = -1) const;
 
     /// Returns the top-most class that has multiple inheritance in the ancestry.
-    static const AbstractMetaClass *getMultipleInheritingClass(const AbstractMetaClass *metaClass);
+    static AbstractMetaClassCPtr
+        getMultipleInheritingClass(const AbstractMetaClassCPtr &metaClass);
 
-    static bool useOverrideCaching(const AbstractMetaClass *metaClass);
-    AttroCheck checkAttroFunctionNeeds(const AbstractMetaClass *metaClass) const;
+    static bool useOverrideCaching(const AbstractMetaClassCPtr &metaClass);
+    static AttroCheck checkAttroFunctionNeeds(const AbstractMetaClassCPtr &metaClass);
 
-    /// Returns a list of methods of the given class where each one is part of a different overload with both static and non-static method.
+    /// Returns a list of methods of the given class where each one is part of
+    /// a different overload with both static and non-static method.
     static AbstractMetaFunctionCList
-        getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass);
+        getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClassCPtr &metaClass);
 
     static void writeToPythonConversion(TextStream &s,
                                         const AbstractMetaType &type,
-                                        const AbstractMetaClass *context,
+                                        const AbstractMetaClassCPtr &context,
                                         const QString &argumentName);
     static void writeToCppConversion(TextStream &s,
                                      const AbstractMetaType &type,
-                                     const AbstractMetaClass *context,
                                      const QString &inArgName,
                                      const QString &outArgName);
     static void writeToCppConversion(TextStream &s,
-                                     const AbstractMetaClass *metaClass, const QString &inArgName,
+                                     const AbstractMetaClassCPtr &metaClass,
+                                     const QString &inArgName,
                                      const QString &outArgName);
 
     /// Returns true if the argument is a pointer that rejects nullptr values.
     static bool shouldRejectNullPointerArgument(const AbstractMetaFunctionCPtr &func,
                                                 int argIndex);
 
-    /// Verifies if the class should have a C++ wrapper generated for it, instead of only a Python wrapper.
-    bool shouldGenerateCppWrapper(const AbstractMetaClass *metaClass) const;
+    /// Verifies if the class should have a C++ wrapper generated for it,
+    /// instead of only a Python wrapper.
+    static bool shouldGenerateCppWrapper(const AbstractMetaClassCPtr &metaClass);
+
+    static bool shouldGenerateMetaObjectFunctions(const AbstractMetaClassCPtr &metaClass);
 
     /// Returns which functions need to be generated into the wrapper class
-    FunctionGeneration functionGeneration(const AbstractMetaFunctionCPtr &func) const;
+    static FunctionGeneration functionGeneration(const AbstractMetaFunctionCPtr &func);
 
     // Return a list of implicit conversions if generation is enabled.
     AbstractMetaFunctionCList implicitConversions(const TypeEntryCPtr &t) const;
 
-    QString wrapperName(const AbstractMetaClass *metaClass) const;
+    static QString wrapperName(const AbstractMetaClassCPtr &metaClass);
+
+    static QString fullPythonClassName(const AbstractMetaClassCPtr &metaClass);
+
+    static QString headerFileNameForContext(const GeneratorContext &context);
+    IncludeGroup baseWrapperIncludes(const GeneratorContext &classContext) const;
 
-    static QString fullPythonClassName(const AbstractMetaClass *metaClass);
     static QString fullPythonFunctionName(const AbstractMetaFunctionCPtr &func, bool forceFunc);
 
-    bool wrapperDiagnostics() const { return m_wrapperDiagnostics; }
+    static bool wrapperDiagnostics();
 
     static QString protectedEnumSurrogateName(const AbstractMetaEnum &metaEnum);
 
     static QString pythonPrimitiveTypeName(const QString &cppTypeName);
 
     static QString pythonOperatorFunctionName(const AbstractMetaFunctionCPtr &func);
+    static QList<AbstractMetaFunctionCList>
+        filterGroupedOperatorFunctions(const AbstractMetaClassCPtr &metaClass,
+                                       OperatorQueryOptions query);
 
     static QString fixedCppTypeName(const TargetToNativeConversion &toNative);
     static QString fixedCppTypeName(const AbstractMetaType &type);
@@ -211,41 +246,42 @@ protected:
     static QString converterObject(const AbstractMetaType &type) ;
     static QString converterObject(const TypeEntryCPtr &type);
 
-    static QString cpythonBaseName(const AbstractMetaClass *metaClass);
+    static QString cpythonBaseName(const AbstractMetaClassCPtr &metaClass);
     static QString cpythonBaseName(const TypeEntryCPtr &type);
+    static QString containerCpythonBaseName(const ContainerTypeEntryCPtr &ctype);
     static QString cpythonBaseName(const AbstractMetaType &type);
-    static QString cpythonTypeName(const AbstractMetaClass *metaClass);
+    static QString cpythonTypeName(const AbstractMetaClassCPtr &metaClass);
     static QString cpythonTypeName(const TypeEntryCPtr &type);
+    static QString cpythonTypeNameExtSet(const TypeEntryCPtr &type);
+    static QString cpythonTypeNameExtSet(const AbstractMetaType &type);
     static QString cpythonTypeNameExt(const TypeEntryCPtr &type);
-    static QString cpythonTypeNameExt(const AbstractMetaType &type) ;
+    static QString cpythonTypeNameExt(const AbstractMetaType &type);
     static QString cpythonCheckFunction(TypeEntryCPtr type);
     static QString cpythonCheckFunction(AbstractMetaType metaType);
     static QString cpythonIsConvertibleFunction(const TypeEntryCPtr &type);
-    static QString cpythonIsConvertibleFunction(AbstractMetaType metaType);
+    static QString cpythonIsConvertibleFunction(const AbstractMetaType &metaType);
     static QString cpythonIsConvertibleFunction(const AbstractMetaArgument &metaArg);
 
-    static QString cpythonToCppConversionFunction(const AbstractMetaClass *metaClass) ;
-    static QString cpythonToCppConversionFunction(const AbstractMetaType &type,
-                                                  const AbstractMetaClass *context = nullptr);
-    static QString cpythonToPythonConversionFunction(const AbstractMetaType &type,
-                                                     const AbstractMetaClass *context = nullptr);
-    static QString cpythonToPythonConversionFunction(const AbstractMetaClass *metaClass);
+    static QString cpythonToCppConversionFunction(const AbstractMetaClassCPtr &metaClass) ;
+    static QString cpythonToCppConversionFunction(const AbstractMetaType &type);
+    static QString cpythonToPythonConversionFunction(const AbstractMetaType &type);
+    static QString cpythonToPythonConversionFunction(const AbstractMetaClassCPtr &metaClass);
     static QString cpythonToPythonConversionFunction(const TypeEntryCPtr &type);
 
     static QString cpythonFunctionName(const AbstractMetaFunctionCPtr &func) ;
     static QString cpythonMethodDefinitionName(const AbstractMetaFunctionCPtr &func);
-    static QString cpythonGettersSettersDefinitionName(const AbstractMetaClass *metaClass);
-    static QString cpythonGetattroFunctionName(const AbstractMetaClass *metaClass);
-    static QString cpythonSetattroFunctionName(const AbstractMetaClass *metaClass);
+    static QString cpythonGettersSettersDefinitionName(const AbstractMetaClassCPtr &metaClass);
+    static QString cpythonGetattroFunctionName(const AbstractMetaClassCPtr &metaClass);
+    static QString cpythonSetattroFunctionName(const AbstractMetaClassCPtr &metaClass);
     static QString cpythonGetterFunctionName(const AbstractMetaField &metaField);
     static QString cpythonSetterFunctionName(const AbstractMetaField &metaField);
     static QString cpythonGetterFunctionName(const QPropertySpec &property,
-                                             const AbstractMetaClass *metaClass);
+                                             const AbstractMetaClassCPtr &metaClass);
     static QString cpythonSetterFunctionName(const QPropertySpec &property,
-                                             const AbstractMetaClass *metaClass);
-    static QString cpythonWrapperCPtr(const AbstractMetaClass *metaClass,
-                                      const QString &argName = QStringLiteral("self"));
-     static QString cpythonWrapperCPtr(const AbstractMetaType &metaType,
+                                             const AbstractMetaClassCPtr &metaClass);
+    static QString cpythonWrapperCPtr(const AbstractMetaClassCPtr &metaClass,
+                                      const QString &argName = QLatin1StringView("self"));
+    static QString cpythonWrapperCPtr(const AbstractMetaType &metaType,
                                       const QString &argName);
     static QString cpythonWrapperCPtr(const TypeEntryCPtr &type, const QString &argName);
 
@@ -254,44 +290,47 @@ protected:
 
     static QString cpythonFlagsName(const FlagsTypeEntryCPtr &flagsEntry);
     static QString cpythonFlagsName(const AbstractMetaEnum *metaEnum);
-    /// Returns the special cast function name, the function used to proper cast class with multiple inheritance.
-    static QString cpythonSpecialCastFunctionName(const AbstractMetaClass *metaClass);
+    /// Returns the special cast function name, the function used to proper cast
+    /// class with multiple inheritance.
+    static QString cpythonSpecialCastFunctionName(const AbstractMetaClassCPtr &metaClass);
 
-    /// Returns the file name for the module global header. If no module name is provided the current will be used.
+    /// Returns the file name for the module global header. If no module name
+    /// is provided the current will be used.
     static QString getModuleHeaderFileName(const QString &moduleName = QString());
     static QString getPrivateModuleHeaderFileName(const QString &moduleName = QString());
 
     /// Includes for header (native wrapper class) or binding source
-    QList<IncludeGroup> classIncludes(const AbstractMetaClass *metaClass) const;
-
-    OptionDescriptions options() const override;
-    bool handleOption(const QString &key, const QString &value) override;
+    QList<IncludeGroup> classIncludes(const AbstractMetaClassCPtr &metaClass) const;
 
     /// Returns true if the user enabled the so called "parent constructor heuristic".
-    bool useCtorHeuristic() const;
+    static bool useCtorHeuristic();
     /// Returns true if the user enabled the so called "return value heuristic".
-    bool useReturnValueHeuristic() const;
+    static bool useReturnValueHeuristic();
     /// Returns true if the generator should use the result of isNull()const to compute boolean casts.
-    bool useIsNullAsNbNonZero() const;
+    static bool useIsNullAsNbBool();
     /// Whether to generate lean module headers
-    bool leanHeaders() const;
+    static bool leanHeaders();
     /// Returns true if the generator should use operator bool to compute boolean casts.
-    bool useOperatorBoolAsNbNonZero() const;
+    static bool useOperatorBoolAsNbBool();
     /// Generate implicit conversions of function arguments
-    bool generateImplicitConversions() const;
+    static bool generateImplicitConversions();
+    static QString cppApiVariableNameOld(const QString &moduleName = {});
     static QString cppApiVariableName(const QString &moduleName = QString());
     static QString pythonModuleObjectName(const QString &moduleName = QString());
     static QString convertersVariableName(const QString &moduleName = QString());
     /// Returns the type index variable name for a given class.
-    static QString getTypeIndexVariableName(const AbstractMetaClass *metaClass);
+    static QString getTypeIndexVariableName(const AbstractMetaClassCPtr &metaClass);
     /// Returns the type index variable name for a given typedef for a template
     /// class instantiation made of the template class and the instantiation values
-    static QString getTypeAlternateTemplateIndexVariableName(const AbstractMetaClass *metaClass);
+    static QString getTypeAlternateTemplateIndexVariableName(const AbstractMetaClassCPtr &metaClass);
     static QString getTypeIndexVariableName(TypeEntryCPtr type);
     static QString getTypeIndexVariableName(const AbstractMetaType &type) ;
 
+    /// Collect all type names as an array for initializing the type/name struct.
+    void collectFullTypeNamesArray(QStringList &typeNames);
+
     /// Returns true if the user don't want verbose error messages on the generated bindings.
-    bool verboseErrorMessagesDisabled() const;
+    static bool verboseErrorMessagesDisabled();
 
     void collectContainerTypesFromConverterMacros(const QString &code, bool toPythonMacro);
 
@@ -324,16 +363,20 @@ protected:
 private:
     static QString getModuleHeaderFileBaseName(const QString &moduleName = QString());
     static QString cpythonGetterFunctionName(const QString &name,
-                                             const AbstractMetaClass *enclosingClass);
+                                             const AbstractMetaClassCPtr &enclosingClass);
     static QString cpythonSetterFunctionName(const QString &name,
-                                             const AbstractMetaClass *enclosingClass);
+                                             const AbstractMetaClassCPtr &enclosingClass);
 
-    static const GeneratorClassInfoCacheEntry &getGeneratorClassInfo(const AbstractMetaClass *scope);
-    static FunctionGroups getFunctionGroupsImpl(const AbstractMetaClass *scope);
-    static bool classNeedsGetattroFunctionImpl(const AbstractMetaClass *metaClass);
+    static const GeneratorClassInfoCacheEntry &
+        getGeneratorClassInfo(const AbstractMetaClassCPtr &scope);
+    static FunctionGroups getFunctionGroupsImpl(const AbstractMetaClassCPtr &scope);
+    static QList<AbstractMetaFunctionCList>
+        getNumberProtocolOperators(const AbstractMetaClassCPtr &metaClass);
+    static BoolCastFunctionOptional getBoolCast(const AbstractMetaClassCPtr &metaClass);
+    static bool classNeedsGetattroFunctionImpl(const AbstractMetaClassCPtr &metaClass);
 
     QString translateTypeForWrapperMethod(const AbstractMetaType &cType,
-                                          const AbstractMetaClass *context,
+                                          const AbstractMetaClassCPtr &context,
                                           Options opt = NoOption) const;
 
     /**
@@ -342,7 +385,7 @@ private:
      *   \param func the metafunction to be searched in subclasses.
      *   \param seen the function's minimal signatures already seen.
      */
-    static void getInheritedOverloads(const AbstractMetaClass *scope,
+    static void getInheritedOverloads(const AbstractMetaClassCPtr &scope,
                                       AbstractMetaFunctionCList *overloads);
 
 
@@ -371,7 +414,7 @@ private:
     QString functionReturnType(const AbstractMetaFunctionCPtr &func, Options options = NoOption) const;
 
     /// Utility function for writeCodeSnips.
-    using ArgumentVarReplacementPair = QPair<AbstractMetaArgument, QString>;
+    using ArgumentVarReplacementPair = std::pair<AbstractMetaArgument, QString>;
     using ArgumentVarReplacementList = QList<ArgumentVarReplacementPair>;
     static ArgumentVarReplacementList
         getArgumentReplacement(const AbstractMetaFunctionCPtr &func,
@@ -433,16 +476,7 @@ private:
     void replaceTemplateVariables(QString &code,
                                   const AbstractMetaFunctionCPtr &func) const;
 
-    bool m_useCtorHeuristic = false;
-    bool m_userReturnValueHeuristic = false;
-    bool m_verboseErrorMessagesDisabled = false;
-    bool m_useIsNullAsNbNonZero = false;
-    // FIXME PYSIDE 7 Flip m_leanHeaders default or remove?
-    bool m_leanHeaders = false;
-    bool m_useOperatorBoolAsNbNonZero = false;
-    // FIXME PYSIDE 7 Flip generateImplicitConversions default or remove?
-    bool m_generateImplicitConversions = true;
-    bool m_wrapperDiagnostics = false;
+    static ShibokenGeneratorOptions m_options;
 
     /// Type system converter variable replacement names and regular expressions.
     static const QHash<int, QString> &typeSystemConvName();
@@ -454,20 +488,4 @@ private:
 Q_DECLARE_OPERATORS_FOR_FLAGS(ShibokenGenerator::FunctionGeneration);
 Q_DECLARE_OPERATORS_FOR_FLAGS(ShibokenGenerator::AttroCheck);
 
-extern const QString CPP_ARG;
-extern const QString CPP_ARG_REMOVED;
-extern const QString CPP_RETURN_VAR;
-extern const QString CPP_SELF_VAR;
-extern const QString NULL_PTR;
-extern const QString PYTHON_ARG;
-extern const QString PYTHON_ARGS;
-extern const QString PYTHON_OVERRIDE_VAR;
-extern const QString PYTHON_RETURN_VAR;
-extern const QString PYTHON_TO_CPP_VAR;
-extern const QString SMART_POINTER_GETTER;
-
-extern const QString CONV_RULE_OUT_VAR_SUFFIX;
-extern const QString BEGIN_ALLOW_THREADS;
-extern const QString END_ALLOW_THREADS;
-
 #endif // SHIBOKENGENERATOR_H
diff --git a/sources/shiboken6/generators/shiboken/shiboken.cpp b/sources/shiboken6/generators/shiboken/shiboken.cpp
deleted file mode 100644
index 193b8e902..000000000
--- a/sources/shiboken6/generators/shiboken/shiboken.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright (C) 2016 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
-
-#include "cppgenerator.h"
-#include "headergenerator.h"
-
-EXPORT_GENERATOR_PLUGIN(new CppGenerator << new HeaderGenerator)
diff --git a/sources/shiboken6/icecc.cmake b/sources/shiboken6/icecc.cmake
index b2bf071aa..fa8d3b7cf 100644
--- a/sources/shiboken6/icecc.cmake
+++ b/sources/shiboken6/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/shiboken6/libshiboken/CMakeLists.txt b/sources/shiboken6/libshiboken/CMakeLists.txt
index 51a682b0e..b5bbb498a 100644
--- a/sources/shiboken6/libshiboken/CMakeLists.txt
+++ b/sources/shiboken6/libshiboken/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(libshiboken)
 
 option(ENABLE_VERSION_SUFFIX "Used to use current version in suffix to generated files. This is used to allow multiples versions installed simultaneous." FALSE)
@@ -27,7 +30,7 @@ if(SHIBOKEN_IS_CROSS_BUILD)
     set(host_python_path "${QFP_PYTHON_HOST_PATH}")
     set(use_pyc_in_embedding FALSE)
 else()
-    set(host_python_path "${PYTHON_EXECUTABLE}")
+    set(host_python_path "${Python_EXECUTABLE}")
     if(PYTHON_LIMITED_API)
         set(use_pyc_in_embedding FALSE)
     else()
@@ -55,39 +58,49 @@ set(libshiboken_VERSION "${libshiboken_MAJOR_VERSION}.${libshiboken_MINOR_VERSIO
 set(libshiboken_SOVERSION "${shiboken6_library_so_version}")
 
 set(libshiboken_SRC
-basewrapper.cpp
-debugfreehook.cpp
-gilstate.cpp
-helper.cpp
-sbkarrayconverter.cpp
-sbkcontainer.cpp
-sbkconverter.cpp
-sbkenum.cpp
-sbkerrors.cpp
-sbkfeature_base.cpp
-sbkmodule.cpp
-sbknumpy.cpp
-sbkcppstring.cpp
-sbkstring.cpp
-sbkstaticstrings.cpp
-sbktypefactory.cpp
-bindingmanager.cpp
-threadstatesaver.cpp
-shibokenbuffer.cpp
-pep384impl.cpp
-voidptr.cpp
-bufferprocs_py37.cpp
+autodecref.h
+basewrapper.cpp basewrapper.h basewrapper_p.h
+bindingmanager.cpp bindingmanager.h
+bufferprocs_py37.cpp bufferprocs_py37.h
+debugfreehook.cpp debugfreehook.h
+gilstate.cpp gilstate.h
+helper.cpp helper.h
+pep384impl.cpp pep384impl.h
+pyobjectholder.h
+sbkarrayconverter.cpp sbkarrayconverter.h sbkarrayconverter_p.h
+sbkcontainer.cpp sbkcontainer.h
+sbkconverter.cpp sbkconverter.h sbkconverter_p.h
+sbkcppstring.cpp sbkcppstring.h sbkcpptonumpy.h
+sbkenum.cpp sbkenum.h
+sbkerrors.cpp sbkerrors.h
+sbkfeature_base.cpp sbkfeature_base.h
+sbkmodule.cpp sbkmodule.h
+sbknumpy.cpp sbknumpycheck.h
+sbknumpyview.h
+sbkpython.h
+sbksmartpointer.cpp sbksmartpointer.h
+sbkstaticstrings.cpp sbkstaticstrings.h sbkstaticstrings_p.h
+sbkstring.cpp sbkstring.h
+sbktypefactory.cpp sbktypefactory.h
+sbkwindows.h
+shiboken.h
+shibokenbuffer.cpp shibokenbuffer.h
+shibokenmacros.h
+threadstatesaver.cpp threadstatesaver.h
+voidptr.cpp voidptr.h
 
 embed/signature_bootstrap_inc.h
 embed/signature_inc.h
 
-signature/signature.cpp
+signature/signature.cpp signature.h signature_p.h
 signature/signature_globals.cpp
 signature/signature_extend.cpp
 signature/signature_helper.cpp
 )
 
-set(APIEXTRACTOR_EXTRA_INCLUDES ${APIEXTRACTOR_EXTRA_INCLUDES} ${LIBXSLT_INCLUDE_DIR} ${LIBXML2_INCLUDE_DIR})
+# This is needed to let the header obey a variable in "pep384impl.h".
+# Note: This must be set on the cpp file!
+set_property(SOURCE "pep384impl.cpp" PROPERTY SKIP_UNITY_BUILD_INCLUSION ON)
 
 add_library(libshiboken SHARED ${libshiboken_SRC})
 add_library(Shiboken6::libshiboken ALIAS libshiboken)
@@ -146,12 +159,12 @@ install(FILES
         bindingmanager.h
         gilstate.h
         helper.h
+        pyobjectholder.h
         sbkarrayconverter.h
         sbkcontainer.h
         sbkconverter.h
         sbkcpptonumpy.h
         sbkenum.h
-        sbkenum_p.h
         sbkerrors.h
         sbkfeature_base.h
         sbkmodule.h
@@ -159,6 +172,7 @@ install(FILES
         sbknumpyview.h
         sbkstring.h
         sbkcppstring.h
+        sbksmartpointer.h
         sbkstaticstrings.h
         sbktypefactory.h
         shiboken.h
@@ -166,7 +180,9 @@ install(FILES
         threadstatesaver.h
         shibokenbuffer.h
         sbkpython.h
+        sbkwindows.h
         pep384impl.h
+        pep384ext.h
         voidptr.h
         bufferprocs_py37.h
         "${CMAKE_CURRENT_BINARY_DIR}/sbkversion.h"
diff --git a/sources/shiboken6/libshiboken/autodecref.h b/sources/shiboken6/libshiboken/autodecref.h
index d2b660676..62a8584e1 100644
--- a/sources/shiboken6/libshiboken/autodecref.h
+++ b/sources/shiboken6/libshiboken/autodecref.h
@@ -5,7 +5,8 @@
 #define AUTODECREF_H
 
 #include "sbkpython.h"
-#include "basewrapper.h"
+
+#include <utility>
 
 struct SbkObject;
 namespace Shiboken
@@ -14,29 +15,27 @@ namespace Shiboken
 /**
  *  AutoDecRef holds a PyObject pointer and decrement its reference counter when destroyed.
  */
-struct LIBSHIBOKEN_API AutoDecRef
+struct AutoDecRef
 {
 public:
     AutoDecRef(const AutoDecRef &) = delete;
-    AutoDecRef(AutoDecRef &&) = delete;
+    AutoDecRef(AutoDecRef &&o) noexcept : m_pyObj{std::exchange(o.m_pyObj, nullptr)} {}
     AutoDecRef &operator=(const AutoDecRef &) = delete;
-    AutoDecRef &operator=(AutoDecRef &&) = delete;
+    AutoDecRef &operator=(AutoDecRef &&o) noexcept
+    {
+        m_pyObj = std::exchange(o.m_pyObj, nullptr);
+        return *this;
+    }
 
-    /**
-     * AutoDecRef constructor.
-     * \param pyobj A borrowed reference to a Python object
-     */
-    explicit AutoDecRef(PyObject *pyObj) : m_pyObj(pyObj) {}
-    /**
-     * AutoDecRef constructor.
-     * \param pyobj A borrowed reference to a Python object
-     */
-    explicit AutoDecRef(SbkObject *pyObj) : m_pyObj(reinterpret_cast<PyObject *>(pyObj)) {}
-    /**
-     * AutoDecref constructor.
-     * To be used later with reset():
-     */
-    AutoDecRef() : m_pyObj(nullptr) {}
+    /// AutoDecRef constructor.
+    /// \param pyobj A borrowed reference to a Python object
+    explicit AutoDecRef(PyObject *pyObj) noexcept : m_pyObj(pyObj) {}
+    /// AutoDecRef constructor.
+    /// \param pyobj A borrowed reference to a wrapped Python object
+    explicit AutoDecRef(SbkObject *pyObj) noexcept : m_pyObj(reinterpret_cast<PyObject *>(pyObj)) {}
+    /// AutoDecref default constructor.
+    /// To be used later with reset():
+    AutoDecRef() noexcept = default;
 
     /// Decref the borrowed python reference
     ~AutoDecRef()
@@ -44,18 +43,19 @@ public:
         Py_XDECREF(m_pyObj);
     }
 
-    inline bool isNull() const { return m_pyObj == nullptr; }
+    [[nodiscard]] bool isNull() const { return m_pyObj == nullptr; }
     /// Returns the pointer of the Python object being held.
-    inline PyObject *object() { return m_pyObj; }
-    inline operator PyObject *() { return m_pyObj; }
+    [[nodiscard]] PyObject *object() const { return m_pyObj; }
+    [[nodiscard]] operator PyObject *() const { return m_pyObj; }
 #ifndef Py_LIMITED_API
-    inline operator PyTupleObject *() { return reinterpret_cast<PyTupleObject *>(m_pyObj); }
+    [[deprecated]] inline operator PyTupleObject *()
+    { return reinterpret_cast<PyTupleObject *>(m_pyObj); }
 #endif
     inline operator bool() const { return m_pyObj != nullptr; }
     inline PyObject *operator->() { return m_pyObj; }
 
     template<typename T>
-    T cast()
+    [[deprecated]] T cast()
     {
         return reinterpret_cast<T>(m_pyObj);
     }
@@ -79,10 +79,9 @@ public:
     }
 
 private:
-    PyObject *m_pyObj;
+    PyObject *m_pyObj = nullptr;
 };
 
 } // namespace Shiboken
 
 #endif // AUTODECREF_H
-
diff --git a/sources/shiboken6/libshiboken/basewrapper.cpp b/sources/shiboken6/libshiboken/basewrapper.cpp
index 24980239d..0ce80d0c6 100644
--- a/sources/shiboken6/libshiboken/basewrapper.cpp
+++ b/sources/shiboken6/libshiboken/basewrapper.cpp
@@ -5,9 +5,12 @@
 #include "basewrapper_p.h"
 #include "bindingmanager.h"
 #include "helper.h"
+#include "pep384ext.h"
 #include "sbkconverter.h"
 #include "sbkenum.h"
+#include "sbkerrors.h"
 #include "sbkfeature_base.h"
+#include "sbkmodule.h"
 #include "sbkstring.h"
 #include "sbkstaticstrings.h"
 #include "sbkstaticstrings_p.h"
@@ -24,7 +27,9 @@
 #include "signature_p.h"
 #include "voidptr.h"
 
+#include <string>
 #include <iostream>
+#include <sstream>
 
 #if defined(__APPLE__)
 #include <dlfcn.h>
@@ -34,7 +39,73 @@ namespace {
     void _destroyParentInfo(SbkObject *obj, bool keepReference);
 }
 
-static void callDestructor(const Shiboken::DtorAccumulatorVisitor::DestructorEntries &dts)
+namespace Shiboken
+{
+// Walk through the first level of non-user-type Sbk base classes relevant for
+// C++ object allocation. Return true from the predicate to terminate.
+template <class Predicate>
+bool walkThroughBases(PyTypeObject *currentType, Predicate predicate)
+{
+    PyObject *bases = currentType->tp_bases;
+    const Py_ssize_t numBases = PyTuple_Size(bases);
+    bool result = false;
+    for (Py_ssize_t i = 0; !result && i < numBases; ++i) {
+        auto type = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(bases, i));
+        if (PyType_IsSubtype(type, SbkObject_TypeF()) != 0) {
+            result = PepType_SOTP(type)->is_user_type
+                     ? walkThroughBases(type, predicate) : predicate(type);
+        }
+    }
+    return result;
+}
+
+int getTypeIndexOnHierarchy(PyTypeObject *baseType, PyTypeObject *desiredType)
+{
+    int index = -1;
+    walkThroughBases(baseType, [&index, desiredType](PyTypeObject *node) {
+        ++index;
+        return PyType_IsSubtype(node, desiredType) != 0;
+    });
+    return index;
+}
+
+int getNumberOfCppBaseClasses(PyTypeObject *baseType)
+{
+    int count = 0;
+    walkThroughBases(baseType, [&count](PyTypeObject *) {
+        ++count;
+        return false;
+    });
+    return count;
+}
+
+std::vector<PyTypeObject *> getCppBaseClasses(PyTypeObject *baseType)
+{
+    std::vector<PyTypeObject *> cppBaseClasses;
+    walkThroughBases(baseType, [&cppBaseClasses](PyTypeObject *node) {
+        cppBaseClasses.push_back(node);
+        return false;
+    });
+    return cppBaseClasses;
+}
+
+using DestructorEntries = std::vector<DestructorEntry>;
+
+DestructorEntries getDestructorEntries(SbkObject *o)
+{
+    DestructorEntries result;
+    void **cptrs = o->d->cptr;
+    walkThroughBases(Py_TYPE(o), [&result, cptrs](PyTypeObject *node) {
+        auto *sotp = PepType_SOTP(node);
+        auto index = result.size();
+        result.push_back(DestructorEntry{sotp->cpp_dtor,
+                                         cptrs[index]});
+        return false;
+    });
+    return result;
+}
+
+static void callDestructor(const DestructorEntries &dts)
 {
     for (const auto &e : dts) {
         Shiboken::ThreadStateSaver threadSaver;
@@ -43,6 +114,8 @@ static void callDestructor(const Shiboken::DtorAccumulatorVisitor::DestructorEnt
     }
 }
 
+} // namespace Shiboken
+
 extern "C"
 {
 
@@ -54,7 +127,7 @@ void Sbk_object_dealloc(PyObject *self)
         // This was not needed before Python 3.8 (Python issue 35810)
         Py_DECREF(Py_TYPE(self));
     }
-    Py_TYPE(self)->tp_free(self);
+    PepExt_TypeCallFree(self);
 }
 
 static void SbkObjectType_tp_dealloc(PyTypeObject *pyType);
@@ -71,6 +144,7 @@ void setDestroyQApplication(DestroyQAppHook func)
 // PYSIDE-535: Use the C API in PyPy instead of `op->ob_dict`, directly
 LIBSHIBOKEN_API PyObject *SbkObject_GetDict_NoRef(PyObject *op)
 {
+    assert(Shiboken::Object::checkType(op));
 #ifdef PYPY_VERSION
     Shiboken::GilState state;
     auto *ret = PyObject_GenericGetDict(op, nullptr);
@@ -109,15 +183,13 @@ type_set_doc(PyTypeObject *type, PyObject *value, void * /* context */)
     if (!check_set_special_type_attr(type, value, "__doc__"))
         return -1;
     PyType_Modified(type);
-    return PyDict_SetItem(type->tp_dict, Shiboken::PyMagicName::doc(), value);
+    Shiboken::AutoDecRef tpDict(PepType_GetDict(type));
+    return PyDict_SetItem(tpDict.object(), Shiboken::PyMagicName::doc(), value);
 }
 
 // PYSIDE-908: The function PyType_Modified does not work in PySide, so we need to
-// explicitly pass __doc__. For __signature__ it _did_ actually work, because
-// it was not existing before. We add them both for clarity.
+// explicitly pass __doc__.
 static PyGetSetDef SbkObjectType_tp_getset[] = {
-    {const_cast<char *>("__signature__"), reinterpret_cast<getter>(Sbk_TypeGet___signature__),
-                                          nullptr, nullptr, nullptr},
     {const_cast<char *>("__doc__"),       reinterpret_cast<getter>(Sbk_TypeGet___doc__),
                                           reinterpret_cast<setter>(type_set_doc), nullptr, nullptr},
     {const_cast<char *>("__dict__"),      reinterpret_cast<getter>(Sbk_TypeGet___dict__),
@@ -125,31 +197,53 @@ static PyGetSetDef SbkObjectType_tp_getset[] = {
     {nullptr, nullptr, nullptr, nullptr, nullptr}  // Sentinel
 };
 
-static PyType_Slot SbkObjectType_Type_slots[] = {
-    {Py_tp_dealloc, reinterpret_cast<void *>(SbkObjectType_tp_dealloc)},
-    {Py_tp_getattro, reinterpret_cast<void *>(mangled_type_getattro)},
-    {Py_tp_base, static_cast<void *>(&PyType_Type)},
-    {Py_tp_alloc, reinterpret_cast<void *>(PyType_GenericAlloc)},
-    {Py_tp_new, reinterpret_cast<void *>(SbkObjectType_tp_new)},
-    {Py_tp_free, reinterpret_cast<void *>(PyObject_GC_Del)},
-    {Py_tp_getset, reinterpret_cast<void *>(SbkObjectType_tp_getset)},
-    {0, nullptr}
-};
-
-// PYSIDE-535: The tp_itemsize field is inherited and does not need to be set.
-// In PyPy, it _must_ not be set, because it would have the meaning that a
-// `__len__` field must be defined. Not doing so creates a hard-to-find crash.
-static PyType_Spec SbkObjectType_Type_spec = {
-    "1:Shiboken.ObjectType",
-    0,
-    0, // sizeof(PyMemberDef), not for PyPy without a __len__ defined
-    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
-    SbkObjectType_Type_slots,
-};
+static PyTypeObject *createObjectTypeType()
+{
+    PyType_Slot SbkObjectType_Type_slots[] = {
+        {Py_tp_dealloc, reinterpret_cast<void *>(SbkObjectType_tp_dealloc)},
+        {Py_tp_getattro, reinterpret_cast<void *>(mangled_type_getattro)},
+        {Py_tp_base, static_cast<void *>(&PyType_Type)},
+        {Py_tp_alloc, reinterpret_cast<void *>(PyType_GenericAlloc)},
+        {Py_tp_new, reinterpret_cast<void *>(SbkObjectType_tp_new)},
+        {Py_tp_free, reinterpret_cast<void *>(PyObject_GC_Del)},
+        {Py_tp_getset, reinterpret_cast<void *>(SbkObjectType_tp_getset)},
+        {0, nullptr}
+    };
+
+    // PYSIDE-535: The tp_itemsize field is inherited and does not need to be set.
+    //             In PyPy, it _must_ not be set, because it would have the meanin
+    //             that a `__len__` field must be defined. Not doing so creates
+    //             a hard-to-find crash.
+    //
+    // PYSIDE-2230: In Python < 3.12, the decision which base class should create
+    //              the instance is arbitrarily drawn by the size of the type.
+    //              Ignoring this creates a bug in the new version of bug_825 that
+    //              selects the wrong metatype.
+    //
+    PyType_Spec SbkObjectType_Type_spec = {
+        "1:Shiboken.ObjectType",
+        static_cast<int>(PyType_Type.tp_basicsize) + 1,           // see above
+        0, // sizeof(PyMemberDef), not for PyPy without a __len__ defined
+        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_TYPE_SUBCLASS,
+        SbkObjectType_Type_slots,
+    };
+
+    PyType_Spec SbkObjectType_Type_spec_312 = {
+        "1:Shiboken.ObjectType",
+        -long(sizeof(SbkObjectTypePrivate)),
+        0, // sizeof(PyMemberDef), not for PyPy without a __len__ defined
+        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_TYPE_SUBCLASS,
+        SbkObjectType_Type_slots,
+    };
+
+    return SbkType_FromSpec(_PepRuntimeVersion() >= 0x030C00 ?
+                            &SbkObjectType_Type_spec_312 :
+                            &SbkObjectType_Type_spec);
+}
 
 PyTypeObject *SbkObjectType_TypeF(void)
 {
-    static auto *type = SbkType_FromSpec(&SbkObjectType_Type_spec);
+    static auto *type = createObjectTypeType();
     return type;
 }
 
@@ -186,10 +280,8 @@ static int SbkObject_tp_traverse(PyObject *self, visitproc visit, void *arg)
     if (sbkSelf->ob_dict)
         Py_VISIT(sbkSelf->ob_dict);
 
-#if PY_VERSION_HEX >= 0x03090000
     // This was not needed before Python 3.9 (Python issue 35810 and 40217)
     Py_VISIT(Py_TYPE(self));
-#endif
     return 0;
 }
 
@@ -209,40 +301,53 @@ static int SbkObject_tp_clear(PyObject *self)
     return 0;
 }
 
-static PyType_Slot SbkObject_Type_slots[] = {
-    {Py_tp_getattro, reinterpret_cast<void *>(SbkObject_GenericGetAttr)},
-    {Py_tp_setattro, reinterpret_cast<void *>(SbkObject_GenericSetAttr)},
-    {Py_tp_dealloc, reinterpret_cast<void *>(SbkDeallocWrapperWithPrivateDtor)},
-    {Py_tp_traverse, reinterpret_cast<void *>(SbkObject_tp_traverse)},
-    {Py_tp_clear, reinterpret_cast<void *>(SbkObject_tp_clear)},
-    // unsupported: {Py_tp_weaklistoffset, (void *)offsetof(SbkObject, weakreflist)},
-    {Py_tp_getset, reinterpret_cast<void *>(SbkObject_tp_getset)},
-    // unsupported: {Py_tp_dictoffset, (void *)offsetof(SbkObject, ob_dict)},
-    {0, nullptr}
-};
-static PyType_Spec SbkObject_Type_spec = {
-    "1:Shiboken.Object",
-    sizeof(SbkObject),
-    0,
-    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
-    SbkObject_Type_slots,
-};
-
-static const char *SbkObject_SignatureStrings[] = {
-    "Shiboken.Object(self)",
-    nullptr}; // Sentinel
+static PyTypeObject *createObjectType()
+{
+    PyType_Slot SbkObject_Type_slots[] = {
+        {Py_tp_getattro, reinterpret_cast<void *>(SbkObject_GenericGetAttr)},
+        {Py_tp_setattro, reinterpret_cast<void *>(SbkObject_GenericSetAttr)},
+        {Py_tp_dealloc, reinterpret_cast<void *>(SbkDeallocWrapperWithPrivateDtor)},
+        {Py_tp_traverse, reinterpret_cast<void *>(SbkObject_tp_traverse)},
+        {Py_tp_clear, reinterpret_cast<void *>(SbkObject_tp_clear)},
+        // unsupported: {Py_tp_weaklistoffset, (void *)offsetof(SbkObject, weakreflist)},
+        {Py_tp_getset, reinterpret_cast<void *>(SbkObject_tp_getset)},
+        // unsupported: {Py_tp_dictoffset, (void *)offsetof(SbkObject, ob_dict)},
+        {0, nullptr}
+    };
+
+    PyType_Spec SbkObject_Type_spec = {
+        "1:Shiboken.Object",
+        sizeof(SbkObject),
+        0,
+        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
+        SbkObject_Type_slots,
+    };
+
+    // PYSIDE-2230: When creating this type, we cannot easily handle the metaclass.
+    //              In versions < Python 3.12, the metaclass can only be set
+    //              indirectly by a base which has that metaclass.
+    //              But before 3.12 is the minimum version, we cannot use the new
+    //              function, although we would need this for 3.12 :-D
+    //              We do a special patching here that is triggered through Py_None.
+    auto *type = SbkType_FromSpec_BMDWB(&SbkObject_Type_spec,
+                                        Py_None,     // bases, spectial flag!
+                                        SbkObjectType_TypeF(),
+                                        offsetof(SbkObject, ob_dict),
+                                        offsetof(SbkObject, weakreflist),
+                                        nullptr);    // bufferprocs
+    return type;
+}
 
 PyTypeObject *SbkObject_TypeF(void)
 {
-    static auto *type = SbkType_FromSpec_BMDWB(&SbkObject_Type_spec,
-                                               nullptr,     // bases
-                                               SbkObjectType_TypeF(),
-                                               offsetof(SbkObject, ob_dict),
-                                               offsetof(SbkObject, weakreflist),
-                                               nullptr);    // bufferprocs
+    static auto *type = createObjectType();    // bufferprocs
     return type;
 }
 
+static const char *SbkObject_SignatureStrings[] = {
+    "Shiboken.Object(self)",
+    nullptr}; // Sentinel
+
 static int mainThreadDeletionHandler(void *)
 {
     if (Py_IsInitialized())
@@ -305,9 +410,8 @@ static void SbkDeallocWrapperCommon(PyObject *pyObj, bool canDelete)
         if (sotp->delete_in_main_thread && Shiboken::currentThreadId() != Shiboken::mainThreadId()) {
             auto &bindingManager = Shiboken::BindingManager::instance();
             if (sotp->is_multicpp) {
-                 Shiboken::DtorAccumulatorVisitor visitor(sbkObj);
-                 Shiboken::walkThroughClassHierarchy(Py_TYPE(pyObj), &visitor);
-                 for (const auto &e : visitor.entries())
+                 const auto entries = Shiboken::getDestructorEntries(sbkObj);
+                 for (const auto &e : entries)
                      bindingManager.addToDeletionInMainThread(e);
             } else {
                 Shiboken::DestructorEntry e{sotp->cpp_dtor, sbkObj->d->cptr[0]};
@@ -325,10 +429,9 @@ static void SbkDeallocWrapperCommon(PyObject *pyObj, bool canDelete)
 
     if (canDelete) {
         if (sotp->is_multicpp) {
-            Shiboken::DtorAccumulatorVisitor visitor(sbkObj);
-            Shiboken::walkThroughClassHierarchy(Py_TYPE(pyObj), &visitor);
+            const auto entries = Shiboken::getDestructorEntries(sbkObj);
             Shiboken::Object::deallocData(sbkObj, true);
-            callDestructor(visitor.entries());
+            callDestructor(entries);
         } else {
             void *cptr = sbkObj->d->cptr[0];
             Shiboken::Object::deallocData(sbkObj, true);
@@ -388,7 +491,7 @@ void SbkObjectType_tp_dealloc(PyTypeObject *sbkType)
     auto pyObj = reinterpret_cast<PyObject *>(sbkType);
 
     PyObject_GC_UnTrack(pyObj);
-#ifndef Py_LIMITED_API
+#if !defined(Py_LIMITED_API) && !defined(PYPY_VERSION)
 #  if PY_VERSION_HEX >= 0x030A0000
     Py_TRASHCAN_BEGIN(pyObj, 1);
 #  else
@@ -406,7 +509,7 @@ void SbkObjectType_tp_dealloc(PyTypeObject *sbkType)
             Shiboken::Conversions::deleteConverter(sotp->converter);
         PepType_SOTP_delete(sbkType);
     }
-#ifndef Py_LIMITED_API
+#if !defined(Py_LIMITED_API) && !defined(PYPY_VERSION)
 #  if PY_VERSION_HEX >= 0x030A0000
     Py_TRASHCAN_END;
 #  else
@@ -477,7 +580,7 @@ static PyTypeObject *SbkObjectType_tp_new(PyTypeObject *metatype, PyObject *args
     PyObject *dict;
     static const char *kwlist[] = { "name", "bases", "dict", nullptr};
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "sO!O!:sbktype", const_cast<char **>(kwlist),
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO!O!:sbktype", const_cast<char **>(kwlist),
                                      &name,
                                      &PyTuple_Type, &pyBases,
                                      &PyDict_Type, &dict))
@@ -485,22 +588,26 @@ static PyTypeObject *SbkObjectType_tp_new(PyTypeObject *metatype, PyObject *args
 
     for (int i=0, i_max=PyTuple_GET_SIZE(pyBases); i < i_max; i++) {
         PyObject *baseType = PyTuple_GET_ITEM(pyBases, i);
-        if (reinterpret_cast<PyTypeObject *>(baseType)->tp_new == SbkDummyNew) {
+        if (PepExt_Type_GetNewSlot(reinterpret_cast<PyTypeObject *>(baseType)) == SbkDummyNew) {
             // PYSIDE-595: A base class does not allow inheritance.
             return reinterpret_cast<PyTypeObject *>(SbkDummyNew(metatype, args, kwds));
         }
     }
 
-    // PYSIDE-939: This is a temporary patch that circumvents the problem
-    // with Py_TPFLAGS_METHOD_DESCRIPTOR until this is finally solved.
-    // PyType_Ready uses mro(). We need to temporarily remove the flag from it's type.
-    // We cannot use PyMethodDescr_Type since it is not exported by Python 2.7 .
-    static PyTypeObject *PyMethodDescr_TypePtr = Py_TYPE(
-        PyObject_GetAttr(reinterpret_cast<PyObject *>(&PyType_Type), Shiboken::PyName::mro()));
-    auto hold = PyMethodDescr_TypePtr->tp_flags;
-    PyMethodDescr_TypePtr->tp_flags &= ~Py_TPFLAGS_METHOD_DESCRIPTOR;
-    auto *newType = PepType_Type_tp_new(metatype, args, kwds);
-    PyMethodDescr_TypePtr->tp_flags = hold;
+    // PYSIDE-939: This is still a temporary patch that circumvents the problem
+    //             with Py_TPFLAGS_METHOD_DESCRIPTOR. The problem exists in Python 3.8
+    //             until 3.9.12, only. We check the runtime and hope for this version valishing.
+    //             https://github.com/python/cpython/issues/92112 will not be fixed for 3.8 :/
+    PyTypeObject *newType{};
+    static auto triplet = _PepRuntimeVersion();
+    if (triplet >= (3 << 16 | 8 << 8 | 0) && triplet < (3 << 16 | 9 << 8 | 13)) {
+        auto hold = PyMethodDescr_Type.tp_flags;
+        PyMethodDescr_Type.tp_flags &= ~Py_TPFLAGS_METHOD_DESCRIPTOR;
+        newType = PepType_Type_tp_new(metatype, args, kwds);
+        PyMethodDescr_Type.tp_flags = hold;
+    } else {
+        newType = PepType_Type_tp_new(metatype, args, kwds);
+    }
 
     if (!newType)
         return nullptr;
@@ -598,9 +705,9 @@ PyObject *SbkQApp_tp_new(PyTypeObject *subtype, PyObject *, PyObject *)
 PyObject *SbkDummyNew(PyTypeObject *type, PyObject *, PyObject *)
 {
     // PYSIDE-595: Give the same error as type_call does when tp_new is NULL.
+    const char regret[] = "¯\\_(ツ)_/¯";
     PyErr_Format(PyExc_TypeError,
-                 "cannot create '%.100s' instances ¯\\_(ツ)_/¯",
-                 type->tp_name);
+                 "cannot create '%.100s' instances %s", type->tp_name, regret);
     return nullptr;
 }
 
@@ -631,6 +738,12 @@ PyObject *FallbackRichCompare(PyObject *self, PyObject *other, int op)
     return res;
 }
 
+bool SbkObjectType_Check(PyTypeObject *type)
+{
+    static auto *meta = SbkObjectType_TypeF();
+    return Py_TYPE(type) == meta || PyType_IsSubtype(Py_TYPE(type), meta);
+}
+
 } //extern "C"
 
 
@@ -655,54 +768,24 @@ void _destroyParentInfo(SbkObject *obj, bool keepReference)
 
 namespace Shiboken
 {
-bool walkThroughClassHierarchy(PyTypeObject *currentType, HierarchyVisitor *visitor)
-{
-    PyObject *bases = currentType->tp_bases;
-    Py_ssize_t numBases = PyTuple_GET_SIZE(bases);
-    bool result = false;
-    for (int i = 0; !result && i < numBases; ++i) {
-        auto type = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(bases, i));
-        if (PyType_IsSubtype(type, reinterpret_cast<PyTypeObject *>(SbkObject_TypeF()))) {
-            result = PepType_SOTP(type)->is_user_type
-                     ? walkThroughClassHierarchy(type, visitor) : visitor->visit(type);
-        }
-    }
-    return result;
-}
 
 // Wrapper metatype and base type ----------------------------------------------------------
 
-HierarchyVisitor::HierarchyVisitor() = default;
-HierarchyVisitor::~HierarchyVisitor() = default;
-
-bool BaseCountVisitor::visit(PyTypeObject *)
-{
-    m_count++;
-    return false;
-}
-
-bool BaseAccumulatorVisitor::visit(PyTypeObject *node)
-{
-    m_bases.push_back(node);
-    return false;
-}
-
-bool GetIndexVisitor::visit(PyTypeObject *node)
-{
-    m_index++;
-    return PyType_IsSubtype(node, m_desiredType);
-}
+void _initMainThreadId(); // helper.cpp
 
-bool DtorAccumulatorVisitor::visit(PyTypeObject *node)
+static std::string msgFailedToInitializeType(const char *description)
 {
-    auto *sotp = PepType_SOTP(node);
-    m_entries.push_back(DestructorEntry{sotp->cpp_dtor,
-                                        m_pyObject->d->cptr[m_entries.size()]});
-    return false;
+    std::ostringstream stream;
+    stream << "[libshiboken] Failed to initialize " << description;
+    if (auto *error = PepErr_GetRaisedException()) {
+        if (auto *str = PyObject_Str(error))
+            stream << ": " << Shiboken::String::toCString(str);
+        Py_DECREF(error);
+    }
+    stream << '.';
+    return stream.str();
 }
 
-void _initMainThreadId(); // helper.cpp
-
 namespace Conversions { void init(); }
 
 void init()
@@ -718,14 +801,13 @@ void init()
     //Init private data
     Pep384_Init();
 
-    if (PyType_Ready(SbkEnumType_TypeF()) < 0)
-        Py_FatalError("[libshiboken] Failed to initialize Shiboken.SbkEnumType metatype.");
+    auto *type = SbkObjectType_TypeF();
+    if (type == nullptr || PyType_Ready(type) < 0)
+        Py_FatalError(msgFailedToInitializeType("Shiboken.BaseWrapperType metatype").c_str());
 
-    if (PyType_Ready(SbkObjectType_TypeF()) < 0)
-        Py_FatalError("[libshiboken] Failed to initialize Shiboken.BaseWrapperType metatype.");
-
-    if (PyType_Ready(SbkObject_TypeF()) < 0)
-        Py_FatalError("[libshiboken] Failed to initialize Shiboken.BaseWrapper type.");
+    type = SbkObject_TypeF();
+    if (type == nullptr || PyType_Ready(type) < 0)
+        Py_FatalError(msgFailedToInitializeType("Shiboken.BaseWrapper type").c_str());
 
     VoidPtr::init();
 
@@ -756,6 +838,32 @@ void setErrorAboutWrongArguments(PyObject *args, const char *funcName, PyObject
     SetError_Argument(args, funcName, info);
 }
 
+PyObject *returnWrongArguments(PyObject *args, const char *funcName, PyObject *info)
+{
+    setErrorAboutWrongArguments(args, funcName, info);
+    return {};
+}
+
+int returnWrongArguments_Zero(PyObject *args, const char *funcName, PyObject *info)
+{
+    setErrorAboutWrongArguments(args, funcName, info);
+    return 0;
+}
+
+int returnWrongArguments_MinusOne(PyObject *args, const char *funcName, PyObject *info)
+{
+    setErrorAboutWrongArguments(args, funcName, info);
+    return -1;
+}
+
+PyObject *returnFromRichCompare(PyObject *result)
+{
+    if (result && !PyErr_Occurred())
+        return result;
+    Shiboken::Errors::setOperatorNotImplemented();
+    return {};
+}
+
 PyObject *checkInvalidArgumentCount(Py_ssize_t numArgs, Py_ssize_t minArgs, Py_ssize_t maxArgs)
 {
     PyObject *result = nullptr;
@@ -773,20 +881,6 @@ PyObject *checkInvalidArgumentCount(Py_ssize_t numArgs, Py_ssize_t minArgs, Py_s
     return result;
 }
 
-class FindBaseTypeVisitor : public HierarchyVisitor
-{
-public:
-    explicit FindBaseTypeVisitor(PyTypeObject *typeToFind) : m_typeToFind(typeToFind) {}
-
-    bool visit(PyTypeObject *node) override
-    {
-        return node == m_typeToFind;
-    }
-
-private:
-    PyTypeObject *m_typeToFind;
-};
-
 std::vector<SbkObject *> splitPyObject(PyObject *pyObj)
 {
     std::vector<SbkObject *> result;
@@ -827,8 +921,8 @@ bool isUserType(PyTypeObject *type)
 
 bool canCallConstructor(PyTypeObject *myType, PyTypeObject *ctorType)
 {
-    FindBaseTypeVisitor visitor(ctorType);
-    if (!walkThroughClassHierarchy(myType, &visitor)) {
+    auto findBasePred = [ctorType](PyTypeObject *type) { return type == ctorType; };
+    if (!walkThroughBases(myType, findBasePred)) {
         PyErr_Format(PyExc_TypeError, "%s isn't a direct base class of %s", ctorType->tp_name, myType->tp_name);
         return false;
     }
@@ -900,31 +994,34 @@ introduceWrapperType(PyObject *enclosingObject,
                      const char *originalName,
                      PyType_Spec *typeSpec,
                      ObjectDestructor cppObjDtor,
-                     PyTypeObject *baseType,
-                     PyObject *baseTypes,
+                     PyObject *bases,
                      unsigned wrapperFlags)
 {
-    auto *base = baseType ? baseType : SbkObject_TypeF();
-    typeSpec->slots[0].pfunc = reinterpret_cast<void *>(base);
-    auto *bases = baseTypes ? baseTypes : PyTuple_Pack(1, base);
+    assert(PySequence_Fast_GET_SIZE(bases) > 0);
+    typeSpec->slots[0].pfunc = PySequence_Fast_GET_ITEM(bases, 0);
 
     auto *type = SbkType_FromSpecBasesMeta(typeSpec, bases, SbkObjectType_TypeF());
 
-    for (int i = 0; i < PySequence_Fast_GET_SIZE(bases); ++i) {
-        auto *st = reinterpret_cast<PyTypeObject *>(PySequence_Fast_GET_ITEM(bases, i));
-        BindingManager::instance().addClassInheritance(st, type);
-    }
-
     auto sotp = PepType_SOTP(type);
     if (wrapperFlags & DeleteInMainThread)
         sotp->delete_in_main_thread = 1;
+    sotp->type_behaviour = (wrapperFlags & Value) != 0
+                           ? BEHAVIOUR_VALUETYPE : BEHAVIOUR_OBJECTTYPE;
 
     setOriginalName(type, originalName);
     setDestructorFunction(type, cppObjDtor);
     auto *ob_type = reinterpret_cast<PyObject *>(type);
 
-    if (wrapperFlags & InnerClass)
+    if (wrapperFlags & InnerClass) {
+        // PYSIDE-2230: Instead of tp_dict, use the enclosing type.
+        //              This stays interface compatible.
+        if (PyType_Check(enclosingObject)) {
+            AutoDecRef tpDict(PepType_GetDict(reinterpret_cast<PyTypeObject *>(enclosingObject)));
+            return PyDict_SetItemString(tpDict, typeName, ob_type) == 0 ? type : nullptr;
+        }
+        assert(PyDict_Check(enclosingObject));
         return PyDict_SetItemString(enclosingObject, typeName, ob_type) == 0 ? type : nullptr;
+    }
 
     // PyModule_AddObject steals type's reference.
     Py_INCREF(ob_type);
@@ -939,16 +1036,19 @@ introduceWrapperType(PyObject *enclosingObject,
 
 void setSubTypeInitHook(PyTypeObject *type, SubTypeInitHook func)
 {
+    assert(SbkObjectType_Check(type));
     PepType_SOTP(type)->subtype_init = func;
 }
 
 void *getTypeUserData(PyTypeObject *type)
 {
+    assert(SbkObjectType_Check(type));
     return PepType_SOTP(type)->user_data;
 }
 
 void setTypeUserData(PyTypeObject *type, void *userData, DeleteUserDataFunc d_func)
 {
+    assert(SbkObjectType_Check(type));
     auto *sotp = PepType_SOTP(type);
     sotp->user_data = userData;
     sotp->d_func = d_func;
@@ -971,6 +1071,26 @@ bool hasSpecialCastFunction(PyTypeObject *sbkType)
     return d != nullptr && d->mi_specialcast != nullptr;
 }
 
+// Find whether base is a direct single line base class of type
+// (no multiple inheritance), that is, a C++ pointer cast can safely be done.
+static bool isDirectAncestor(PyTypeObject *type, PyTypeObject *base)
+{
+    if (type == base)
+        return true;
+    if (PyTuple_Size(type->tp_bases) == 0)
+        return false;
+    auto *sbkObjectType = SbkObject_TypeF();
+    auto *firstBase = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(type->tp_bases, 0));
+    return firstBase != sbkObjectType
+           && PyType_IsSubtype(type, sbkObjectType) != 0
+           && isDirectAncestor(firstBase, base);
+}
+
+bool canDowncastTo(PyTypeObject *baseType, PyTypeObject *targetType)
+{
+    return isDirectAncestor(targetType, baseType);
+}
+
 } // namespace ObjectType
 
 
@@ -1059,9 +1179,7 @@ void callCppDestructors(SbkObject *pyObj)
     PyTypeObject *type = Py_TYPE(pyObj);
     auto *sotp = PepType_SOTP(type);
     if (sotp->is_multicpp) {
-        Shiboken::DtorAccumulatorVisitor visitor(pyObj);
-        Shiboken::walkThroughClassHierarchy(type, &visitor);
-        callDestructor(visitor.entries());
+        callDestructor(getDestructorEntries(pyObj));
     } else {
         Shiboken::ThreadStateSaver threadSaver;
         threadSaver.save();
@@ -1210,11 +1328,10 @@ void makeValid(SbkObject *self)
 
     // If has ref to other objects make all valid again
     if (self->d->referredObjects) {
-        RefCountMap &refCountMap = *(self->d->referredObjects);
-        RefCountMap::iterator iter;
-        for (auto it = refCountMap.begin(), end = refCountMap.end(); it != end; ++it) {
-            if (Shiboken::Object::checkType(it->second))
-                makeValid(reinterpret_cast<SbkObject *>(it->second));
+        const RefCountMap &refCountMap = *(self->d->referredObjects);
+        for (const auto &p : refCountMap) {
+            if (Shiboken::Object::checkType(p.second))
+                makeValid(reinterpret_cast<SbkObject *>(p.second));
         }
     }
 }
@@ -1250,7 +1367,8 @@ bool setCppPointer(SbkObject *sbkObj, PyTypeObject *desiredType, void *cptr)
 
     const bool alreadyInitialized = sbkObj->d->cptr[idx] != nullptr;
     if (alreadyInitialized)
-        PyErr_SetString(PyExc_RuntimeError, "You can't initialize an object twice!");
+        PyErr_Format(PyExc_RuntimeError, "You can't initialize an %s object in class %s twice!",
+                                         desiredType->tp_name, type->tp_name);
     else
         sbkObj->d->cptr[idx] = cptr;
 
@@ -1342,20 +1460,67 @@ SbkObject *findColocatedChild(SbkObject *wrapper,
     return nullptr;
 }
 
+// Legacy, for compatibility only.
 PyObject *newObject(PyTypeObject *instanceType,
                     void *cptr,
                     bool hasOwnership,
                     bool isExactType,
                     const char *typeName)
 {
-    // Try to find the exact type of cptr.
-    if (!isExactType) {
-        if (PyTypeObject *exactType = ObjectType::typeForTypeName(typeName))
-            instanceType = exactType;
-        else
-            instanceType = BindingManager::instance().resolveType(&cptr, instanceType);
+    return isExactType
+        ? newObjectForType(instanceType, cptr, hasOwnership)
+        : newObjectWithHeuristics(instanceType, cptr, hasOwnership, typeName);
+}
+
+static PyObject *newObjectWithHeuristicsHelper(PyTypeObject *instanceType,
+                                               PyTypeObject *exactType,
+                                               void *cptr,
+                                               bool hasOwnership)
+{
+    // Try to find the exact type of cptr. For hierarchies with
+    // non-virtual destructors, typeid() will return the base name.
+    // Try type discovery in these cases.
+    if (exactType == nullptr || exactType == instanceType) {
+        auto resolved = BindingManager::instance().findDerivedType(cptr, instanceType);
+        if (resolved.first != nullptr
+            && Shiboken::ObjectType::canDowncastTo(instanceType, resolved.first)) {
+            exactType = resolved.first;
+            cptr = resolved.second;
+        }
     }
 
+    return newObjectForType(exactType != nullptr ? exactType : instanceType,
+                            cptr, hasOwnership);
+}
+
+PyObject *newObjectForPointer(PyTypeObject *instanceType,
+                              void *cptr,
+                              bool hasOwnership,
+                              const char *typeName)
+{
+    // Try to find the exact type of cptr.
+    PyTypeObject *exactType = ObjectType::typeForTypeName(typeName);
+    // PYSIDE-868: In case of multiple inheritance, (for example,
+    // a function returning a QPaintDevice * from a QWidget *),
+    // use instance type to avoid pointer offset errors.
+    return exactType != nullptr && !Shiboken::ObjectType::canDowncastTo(instanceType, exactType)
+        ? newObjectForType(instanceType, cptr, hasOwnership)
+        : newObjectWithHeuristicsHelper(instanceType, exactType, cptr, hasOwnership);
+}
+
+
+PyObject *newObjectWithHeuristics(PyTypeObject *instanceType,
+                                  void *cptr,
+                                  bool hasOwnership,
+                                  const char *typeName)
+{
+    return newObjectWithHeuristicsHelper(instanceType,
+                                         ObjectType::typeForTypeName(typeName),
+                                         cptr, hasOwnership);
+}
+
+PyObject *newObjectForType(PyTypeObject *instanceType, void *cptr, bool hasOwnership)
+{
     bool shouldCreate = true;
     bool shouldRegister = true;
     SbkObject *self = nullptr;
@@ -1564,7 +1729,7 @@ void deallocData(SbkObject *self, bool cleanup)
     }
     delete self->d; // PYSIDE-205: always delete d.
     Py_XDECREF(self->ob_dict);
-    Py_TYPE(self)->tp_free(self);
+    PepExt_TypeCallFree(reinterpret_cast<PyObject *>(self));
 }
 
 void setTypeUserData(SbkObject *wrapper, void *userData, DeleteUserDataFunc d_func)
@@ -1656,6 +1821,11 @@ static std::vector<PyTypeObject *> getBases(SbkObject *self)
         : std::vector<PyTypeObject *>(1, Py_TYPE(self));
 }
 
+static bool isValueType(SbkObject *self)
+{
+    return PepType_SOTP(Py_TYPE(self))->type_behaviour == BEHAVIOUR_VALUETYPE;
+}
+
 void _debugFormat(std::ostream &s, SbkObject *self)
 {
     assert(self);
@@ -1679,6 +1849,8 @@ void _debugFormat(std::ostream &s, SbkObject *self)
         s << " [validCppObject]";
     if (d->cppObjectCreated)
         s << " [wasCreatedByPython]";
+    s << (isValueType(self) ? " [value]" : " [object]");
+
     if (d->parentInfo) {
         if (auto *parent = d->parentInfo->parent)
             s << ", parent=" << reinterpret_cast<PyObject *>(parent)->ob_type->tp_name
@@ -1709,8 +1881,9 @@ std::string info(SbkObject *self)
     s << "hasOwnership...... " << bool(self->d->hasOwnership) << "\n"
          "containsCppWrapper " << self->d->containsCppWrapper << "\n"
          "validCppObject.... " << self->d->validCppObject << "\n"
-         "wasCreatedByPython " << self->d->cppObjectCreated << "\n";
-
+         "wasCreatedByPython " << self->d->cppObjectCreated << "\n"
+         "value......        " << isValueType(self) << "\n"
+         "reference count... " << reinterpret_cast<PyObject *>(self)->ob_refcnt << '\n';
 
     if (self->d->parentInfo && self->d->parentInfo->parent) {
         s << "parent............ ";
@@ -1728,17 +1901,17 @@ std::string info(SbkObject *self)
     }
 
     if (self->d->referredObjects && !self->d->referredObjects->empty()) {
-        Shiboken::RefCountMap &map = *self->d->referredObjects;
+        const Shiboken::RefCountMap &map = *self->d->referredObjects;
         s << "referred objects.. ";
         std::string lastKey;
-        for (auto it = map.begin(), end = map.end(); it != end; ++it) {
-            if (it->first != lastKey) {
+        for (const auto &p : map) {
+            if (p.first != lastKey) {
                 if (!lastKey.empty())
                     s << "                   ";
-                s << '"' << it->first << "\" => ";
-                lastKey = it->first;
+                s << '"' << p.first << "\" => ";
+                lastKey = p.first;
             }
-            Shiboken::AutoDecRef obj(PyObject_Str(it->second));
+            Shiboken::AutoDecRef obj(PyObject_Str(p.second));
             s << String::toCString(obj) << ' ';
         }
         s << '\n';
diff --git a/sources/shiboken6/libshiboken/basewrapper.h b/sources/shiboken6/libshiboken/basewrapper.h
index 2c54c7d6a..ec5545aea 100644
--- a/sources/shiboken6/libshiboken/basewrapper.h
+++ b/sources/shiboken6/libshiboken/basewrapper.h
@@ -38,32 +38,30 @@ LIBSHIBOKEN_API void SbkDeallocQAppWrapper(PyObject *pyObj);
 LIBSHIBOKEN_API void SbkDeallocWrapperWithPrivateDtor(PyObject *self);
 
 /// Function signature for the multiple inheritance information initializers that should be provided by classes with multiple inheritance.
-typedef int *(*MultipleInheritanceInitFunction)(const void *);
+using MultipleInheritanceInitFunction = int *(*)(const void *);
 
 /**
  *   Special cast function is used to correctly cast an object when it's
  *   part of a multiple inheritance hierarchy.
  *   The implementation of this function is auto generated by the generator and you don't need to care about it.
  */
-typedef void *(*SpecialCastFunction)(void *, PyTypeObject *);
-typedef PyTypeObject *(*TypeDiscoveryFunc)(void *, PyTypeObject *);
-typedef void *(*TypeDiscoveryFuncV2)(void *, PyTypeObject *);
+using SpecialCastFunction = void *(*)(void *, PyTypeObject *);
+using TypeDiscoveryFunc = PyTypeObject *(*)(void *, PyTypeObject *);
+using TypeDiscoveryFuncV2 = void *(*)(void *, PyTypeObject *);
 
 // Used in userdata dealloc function
-typedef void (*DeleteUserDataFunc)(void *);
+using DeleteUserDataFunc = void (*)(void *);
 
-typedef void (*ObjectDestructor)(void *);
+using ObjectDestructor = void (*)(void *);
 
-typedef void (*SubTypeInitHook)(PyTypeObject *, PyObject *, PyObject *);
+using SubTypeInitHook = void (*)(PyTypeObject *, PyObject *, PyObject *);
 
 /// PYSIDE-1019: Set the function to select the current feature.
 /// Return value is the previous content.
-typedef PyObject *(*SelectableFeatureHook)(PyTypeObject *);
+using SelectableFeatureHook = void (*)(PyTypeObject *);
+using SelectableFeatureCallback = void (*)(bool);
 LIBSHIBOKEN_API SelectableFeatureHook initSelectableFeature(SelectableFeatureHook func);
-
-/// PYSIDE-1019: Get access to PySide reserved bits.
-LIBSHIBOKEN_API int SbkObjectType_GetReserved(PyTypeObject *type);
-LIBSHIBOKEN_API void SbkObjectType_SetReserved(PyTypeObject *type, int value);
+LIBSHIBOKEN_API void setSelectableFeatureCallback(SelectableFeatureCallback func);
 
 /// PYSIDE-1626: Enforcing a context switch without further action.
 LIBSHIBOKEN_API void SbkObjectType_UpdateFeature(PyTypeObject *type);
@@ -76,7 +74,7 @@ LIBSHIBOKEN_API void SbkObjectType_SetPropertyStrings(PyTypeObject *type, const
 LIBSHIBOKEN_API void SbkObjectType_SetEnumFlagInfo(PyTypeObject *type, const char **strings);
 
 /// PYSIDE-1470: Set the function to kill a Q*Application.
-typedef void(*DestroyQAppHook)();
+using DestroyQAppHook = void(*)();
 LIBSHIBOKEN_API void setDestroyQApplication(DestroyQAppHook func);
 
 /// PYSIDE-535: Use the C API in PyPy instead of `op->ob_dict`, directly (borrowed ref)
@@ -114,6 +112,9 @@ LIBSHIBOKEN_API PyObject *FallbackRichCompare(PyObject *self, PyObject *other, i
 /// PYSIDE-1970: Be easily able to see what is happening in the running code.
 LIBSHIBOKEN_API void disassembleFrame(const char *marker);
 
+/// PYSIDE-2230: Check if an object is an SbkObject.
+LIBSHIBOKEN_API bool SbkObjectType_Check(PyTypeObject *type);
+
 } // extern "C"
 
 namespace Shiboken
@@ -134,11 +135,25 @@ void callCppDestructor(void *cptr)
     delete reinterpret_cast<T *>(cptr);
 }
 
-// setErrorAboutWrongArguments now gets overload information from the signature module.
-// The extra info argument can contain additional data about the error.
+/// setErrorAboutWrongArguments now gets overload information from the signature module.
+/// The extra info argument can contain additional data about the error.
 LIBSHIBOKEN_API void setErrorAboutWrongArguments(PyObject *args, const char *funcName,
                                                  PyObject *info);
 
+/// Return values for the different retun variants.
+/// This is used instead of goto.
+LIBSHIBOKEN_API PyObject *returnWrongArguments(PyObject *args, const char *funcName,
+                                               PyObject *info);
+
+LIBSHIBOKEN_API int returnWrongArguments_Zero(PyObject *args, const char *funcName,
+                                                    PyObject *info);
+
+LIBSHIBOKEN_API int returnWrongArguments_MinusOne(PyObject *args, const char *funcName,
+                                                        PyObject *info);
+
+/// A simple special version for the end of rich comparison.
+LIBSHIBOKEN_API PyObject *returnFromRichCompare(PyObject *result);
+
 // Return error information object if the argument count is wrong
 LIBSHIBOKEN_API PyObject *checkInvalidArgumentCount(Py_ssize_t numArgs,
                                                     Py_ssize_t minArgs,
@@ -185,14 +200,15 @@ LIBSHIBOKEN_API const char *getOriginalName(PyTypeObject *self);
 LIBSHIBOKEN_API void setTypeDiscoveryFunctionV2(PyTypeObject *self, TypeDiscoveryFuncV2 func);
 LIBSHIBOKEN_API void copyMultipleInheritance(PyTypeObject *self, PyTypeObject *other);
 LIBSHIBOKEN_API void setMultipleInheritanceFunction(PyTypeObject *self, MultipleInheritanceInitFunction func);
-LIBSHIBOKEN_API MultipleInheritanceInitFunction getMultipleInheritanceFunction(PyTypeObject *self);
+LIBSHIBOKEN_API MultipleInheritanceInitFunction getMultipleInheritanceFunction(PyTypeObject *type);
 
 LIBSHIBOKEN_API void setDestructorFunction(PyTypeObject *self, ObjectDestructor func);
 
 enum WrapperFlags
 {
     InnerClass = 0x1,
-    DeleteInMainThread = 0x2
+    DeleteInMainThread = 0x2,
+    Value = 0x4
 };
 
 /**
@@ -213,13 +229,12 @@ enum WrapperFlags
  *  \returns                true if the initialization went fine, false otherwise.
  */
 LIBSHIBOKEN_API PyTypeObject *introduceWrapperType(PyObject *enclosingObject,
-                                                    const char *typeName,
-                                                    const char *originalName,
-                                                    PyType_Spec *typeSpec,
-                                                    ObjectDestructor cppObjDtor,
-                                                    PyTypeObject *baseType,
-                                                    PyObject *baseTypes,
-                                                    unsigned wrapperFlags = 0);
+                                                   const char *typeName,
+                                                   const char *originalName,
+                                                   PyType_Spec *typeSpec,
+                                                   ObjectDestructor cppObjDtor,
+                                                   PyObject *bases,
+                                                   unsigned wrapperFlags = 0);
 
 /**
  *  Set the subtype init hook for a type.
@@ -250,6 +265,14 @@ LIBSHIBOKEN_API PyTypeObject *typeForTypeName(const char *typeName);
  * \since 5.12
  */
 LIBSHIBOKEN_API bool hasSpecialCastFunction(PyTypeObject *sbkType);
+
+/// Returns whether a C++ pointer of \p baseType can be safely downcast
+/// to \p targetType (base is a direct, single line base class of targetType).
+/// (is a direct, single-line inheritance)
+/// \param baseType   Python type of base class
+/// \param targetType Python type of derived class
+/// \since 6.8
+LIBSHIBOKEN_API bool canDowncastTo(PyTypeObject *baseType, PyTypeObject *targetType);
 }
 
 namespace Object {
@@ -282,7 +305,8 @@ LIBSHIBOKEN_API SbkObject *findColocatedChild(SbkObject *wrapper,
                                               const PyTypeObject *instanceType);
 
 /**
- *  Bind a C++ object to Python.
+ *  Bind a C++ object to Python. Forwards to
+ *  newObjectWithHeuristics(), newObjectForType() depending on \p isExactType.
  * \param instanceType equivalent Python type for the C++ object.
  * \param hasOwnership if true, Python will try to delete the underlying C++ object when there's no more refs.
  * \param isExactType if false, Shiboken will use some heuristics to detect the correct Python type of this C++
@@ -296,6 +320,40 @@ LIBSHIBOKEN_API PyObject *newObject(PyTypeObject *instanceType,
                                     bool isExactType = false,
                                     const char *typeName = nullptr);
 
+/// Bind a C++ object to Python for polymorphic pointers. Calls
+/// newObjectWithHeuristics() with an additional check for multiple
+/// inheritance, in which case it will fall back to instanceType.
+/// \param instanceType Equivalent Python type for the C++ object.
+/// \param hasOwnership if true, Python will try to delete the underlying C++ object
+///                     when there's no more refs.
+/// \param typeName     If non-null, this will be used as helper to find the correct
+///                     Python type for this object (obtained by typeid().name().
+LIBSHIBOKEN_API PyObject *newObjectForPointer(PyTypeObject *instanceType,
+                                              void *cptr,
+                                              bool hasOwnership = true,
+                                              const char *typeName = nullptr);
+
+/// Bind a C++ object to Python using some heuristics to detect the correct
+/// Python type of this C++ object. In any case \p instanceType must be provided;
+/// it'll be used as search starting point and as fallback.
+/// \param instanceType Equivalent Python type for the C++ object.
+/// \param hasOwnership if true, Python will try to delete the underlying C++ object
+///                     C++ object when there are no more references.
+///                     when there's no more refs.
+/// \param typeName     If non-null, this will be used as helper to find the correct
+///                     Python type for this object (obtained by typeid().name().
+LIBSHIBOKEN_API PyObject *newObjectWithHeuristics(PyTypeObject *instanceType,
+                                                  void *cptr,
+                                                  bool hasOwnership = true,
+                                                  const char *typeName = nullptr);
+
+/// Bind a C++ object to Python using the given type.
+/// \param instanceType Equivalent Python type for the C++ object.
+/// \param hasOwnership if true, Python will try to delete the underlying
+///                     C++ object when there are no more references.
+LIBSHIBOKEN_API PyObject *newObjectForType(PyTypeObject *instanceType,
+                                           void *cptr, bool hasOwnership = true);
+
 /**
  *  Changes the valid flag of a PyObject, invalid objects will raise an exception when someone tries to access it.
  */
diff --git a/sources/shiboken6/libshiboken/basewrapper_p.h b/sources/shiboken6/libshiboken/basewrapper_p.h
index 9f163836d..fb9140793 100644
--- a/sources/shiboken6/libshiboken/basewrapper_p.h
+++ b/sources/shiboken6/libshiboken/basewrapper_p.h
@@ -30,14 +30,12 @@ using ChildrenList = std::set<SbkObject *>;
 /// Structure used to store information about object parent and children.
 struct ParentInfo
 {
-    /// Default ctor.
-    ParentInfo() : parent(nullptr), hasWrapperRef(false) {}
     /// Pointer to parent object.
-    SbkObject *parent;
+    SbkObject *parent = nullptr;
     /// List of object children.
     ChildrenList children;
     /// has internal ref
-    bool hasWrapperRef;
+    bool hasWrapperRef = false;
 };
 
 } // namespace Shiboken
@@ -51,6 +49,12 @@ extern "C"
  */
 struct SbkObjectPrivate
 {
+    SbkObjectPrivate() noexcept = default;
+    SbkObjectPrivate(const SbkObjectPrivate &) = delete;
+    SbkObjectPrivate(SbkObjectPrivate &&o) = delete;
+    SbkObjectPrivate &operator=(const SbkObjectPrivate &) = delete;
+    SbkObjectPrivate &operator=(SbkObjectPrivate &&o) = delete;
+
     /// Pointer to the C++ class.
     void ** cptr;
     /// True when Python is responsible for freeing the used memory.
@@ -97,15 +101,6 @@ struct SbkObjectTypePrivate
     TypeDiscoveryFuncV2 type_discovery;
     /// Pointer to a function responsible for deletion of the C++ instance calling the proper destructor.
     ObjectDestructor cpp_dtor;
-    /// PYSIDE-1019: Caching the current select Id
-    unsigned int pyside_reserved_bits : 8;   // MSVC has bug with the sign bit!
-    /// True if this type holds two or more C++ instances, e.g.: a Python class which inherits from two C++ classes.
-    unsigned int is_multicpp : 1;
-    /// True if this type was defined by the user.
-    unsigned int is_user_type : 1;
-    /// Tells is the type is a value type or an object-type, see BEHAVIOUR_ *constants.
-    unsigned int type_behaviour : 2;
-    unsigned int delete_in_main_thread : 1;
     /// C++ name
     char *original_name;
     /// Type user data
@@ -116,6 +111,15 @@ struct SbkObjectTypePrivate
     const char **enumFlagInfo;
     PyObject *enumFlagsDict;
     PyObject *enumTypeDict;
+
+    /// True if this type holds two or more C++ instances, e.g.: a Python class which inherits from two C++ classes.
+    unsigned int is_multicpp : 1;
+    /// True if this type was defined by the user (a class written in Python inheriting
+    /// a class provided by a Shiboken binding).
+    unsigned int is_user_type : 1;
+    /// Tells is the type is a value type or an object-type, see BEHAVIOUR_ *constants.
+    unsigned int type_behaviour : 2;
+    unsigned int delete_in_main_thread : 1;
 };
 
 
@@ -139,107 +143,7 @@ struct DestructorEntry
  **/
 std::vector<SbkObject *> splitPyObject(PyObject *pyObj);
 
-/**
-*   Visitor class used by walkOnClassHierarchy function.
-*/
-class HierarchyVisitor
-{
-public:
-    HierarchyVisitor(const HierarchyVisitor &) = delete;
-    HierarchyVisitor(HierarchyVisitor &&) = delete;
-    HierarchyVisitor &operator=(const HierarchyVisitor &) = delete;
-    HierarchyVisitor &operator=(HierarchyVisitor &&) = delete;
-
-    HierarchyVisitor();
-    virtual ~HierarchyVisitor();
-
-    virtual bool visit(PyTypeObject *node) = 0; // return true to terminate
-};
-
-class BaseCountVisitor : public HierarchyVisitor
-{
-public:
-    bool visit(PyTypeObject *) override;
-
-    int count() const { return m_count; }
-
-private:
-    int m_count = 0;
-};
-
-class BaseAccumulatorVisitor : public HierarchyVisitor
-{
-public:
-    using Result = std::vector<PyTypeObject *>;
-
-    bool visit(PyTypeObject *node) override;
-
-    Result bases() const { return m_bases; }
-
-private:
-    Result m_bases;
-};
-
-class GetIndexVisitor : public HierarchyVisitor
-{
-public:
-    explicit GetIndexVisitor(PyTypeObject *desiredType) : m_desiredType(desiredType) {}
-
-    bool visit(PyTypeObject *node) override;
-
-    int index() const { return m_index; }
-
-private:
-    int m_index = -1;
-    PyTypeObject *m_desiredType;
-};
-
-/// Collect destructors and C++ instances of each C++ object held by a Python
-/// object
-class DtorAccumulatorVisitor : public HierarchyVisitor
-{
-public:
-    explicit DtorAccumulatorVisitor(SbkObject *pyObj) : m_pyObject(pyObj) {}
-
-    bool visit(PyTypeObject *node) override;
-
-    using DestructorEntries = std::vector<DestructorEntry>;
-
-    const DestructorEntries &entries() const { return m_entries; }
-
-private:
-    DestructorEntries m_entries;
-    SbkObject *m_pyObject;
-};
-
-/// \internal Internal function used to walk on classes inheritance trees.
-/**
-*   Walk on class hierarchy using a DFS algorithm.
-*   For each pure Shiboken type found, HierarchyVisitor::visit is called and the algorithm
-*   considers all children of this type as visited.
-*/
-bool walkThroughClassHierarchy(PyTypeObject *currentType, HierarchyVisitor *visitor);
-
-inline int getTypeIndexOnHierarchy(PyTypeObject *baseType, PyTypeObject *desiredType)
-{
-    GetIndexVisitor visitor(desiredType);
-    walkThroughClassHierarchy(baseType, &visitor);
-    return visitor.index();
-}
-
-inline int getNumberOfCppBaseClasses(PyTypeObject *baseType)
-{
-    BaseCountVisitor visitor;
-    walkThroughClassHierarchy(baseType, &visitor);
-    return visitor.count();
-}
-
-inline std::vector<PyTypeObject *> getCppBaseClasses(PyTypeObject *baseType)
-{
-    BaseAccumulatorVisitor visitor;
-    walkThroughClassHierarchy(baseType, &visitor);
-    return visitor.bases();
-}
+int getNumberOfCppBaseClasses(PyTypeObject *baseType);
 
 namespace Object
 {
diff --git a/sources/shiboken6/libshiboken/bindingmanager.cpp b/sources/shiboken6/libshiboken/bindingmanager.cpp
index 9d74e9721..83c927ae5 100644
--- a/sources/shiboken6/libshiboken/bindingmanager.cpp
+++ b/sources/shiboken6/libshiboken/bindingmanager.cpp
@@ -6,101 +6,162 @@
 #include "basewrapper_p.h"
 #include "bindingmanager.h"
 #include "gilstate.h"
+#include "helper.h"
+#include "sbkmodule.h"
 #include "sbkstring.h"
 #include "sbkstaticstrings.h"
 #include "sbkfeature_base.h"
 #include "debugfreehook.h"
 
 #include <cstddef>
+#include <cstring>
 #include <fstream>
+#include <iostream>
 #include <mutex>
+#include <string_view>
 #include <unordered_map>
+#include <unordered_set>
+
+// GraphNode for the dependency graph. It keeps a pointer to
+// the TypeInitStruct to be able to lazily create the type and hashes
+// by the full type name.
+struct GraphNode
+{
+    explicit GraphNode(Shiboken::Module::TypeInitStruct *i) : name(i->fullName), initStruct(i) {}
+    explicit GraphNode(const char *n) : name(n), initStruct(nullptr) {} // Only for searching
+
+    std::string_view name;
+    Shiboken::Module::TypeInitStruct *initStruct;
+
+    friend bool operator==(const GraphNode &n1, const GraphNode &n2) { return n1.name == n2.name; }
+    friend bool operator!=(const GraphNode &n1, const GraphNode &n2) { return n1.name != n2.name; }
+};
+
+template <>
+struct std::hash<GraphNode> {
+    size_t operator()(const GraphNode &n) const noexcept
+    {
+        return std::hash<std::string_view>{}(n.name);
+    }
+};
 
 namespace Shiboken
 {
 
 using WrapperMap = std::unordered_map<const void *, SbkObject *>;
 
-class Graph
+template <class NodeType>
+class BaseGraph
 {
 public:
-    using NodeList = std::vector<PyTypeObject *>;
-    using Edges = std::unordered_map<PyTypeObject *, NodeList>;
+    using NodeList = std::vector<NodeType>;
+    using NodeSet = std::unordered_set<NodeType>;
+
+    using Edges = std::unordered_map<NodeType, NodeList>;
 
     Edges m_edges;
 
-    Graph() = default;
+    BaseGraph() = default;
 
-    void addEdge(PyTypeObject *from, PyTypeObject *to)
+    void addEdge(NodeType from, NodeType to)
     {
         m_edges[from].push_back(to);
     }
 
-#ifndef NDEBUG
-    void dumpDotGraph()
+    NodeSet nodeSet() const
     {
-        std::ofstream file("/tmp/shiboken_graph.dot");
-
-        file << "digraph D {\n";
-
-        for (auto i = m_edges.begin(), end = m_edges.end(); i != end; ++i) {
-            auto *node1 = i->first;
-            const NodeList &nodeList = i->second;
-            for (const PyTypeObject *o : nodeList) {
-                auto *node2 = o;
-                file << '"' << node2->tp_name << "\" -> \""
-                    << node1->tp_name << "\"\n";
-            }
+        NodeSet result;
+        for (const auto &p : m_edges) {
+            result.insert(p.first);
+            for (const auto node2 : p.second)
+                result.insert(node2);
         }
-        file << "}\n";
+        return result;
     }
-#endif
+};
+
+class Graph : public BaseGraph<GraphNode>
+{
+public:
+    using TypeCptrPair = BindingManager::TypeCptrPair;
 
-    PyTypeObject *identifyType(void **cptr, PyTypeObject *type, PyTypeObject *baseType) const
+    TypeCptrPair identifyType(void *cptr, PyTypeObject *type, PyTypeObject *baseType) const
     {
-        auto edgesIt = m_edges.find(type);
-        if (edgesIt != m_edges.end()) {
-            const NodeList &adjNodes = m_edges.find(type)->second;
-            for (PyTypeObject *node : adjNodes) {
-                PyTypeObject *newType = identifyType(cptr, node, baseType);
-                if (newType)
-                    return newType;
-            }
-        }
-        void *typeFound = nullptr;
-        auto *sotp = PepType_SOTP(type);
-        if (sotp->type_discovery)
-            typeFound = sotp->type_discovery(*cptr, baseType);
-        if (typeFound) {
-            // This "typeFound != type" is needed for backwards compatibility with old modules using a newer version of
-            // libshiboken because old versions of type_discovery function used to return a PyTypeObject *instead of
-            // a possible variation of the C++ instance pointer (*cptr).
-            if (typeFound != type)
-                *cptr = typeFound;
-            return type;
-        }
-        return nullptr;
+        return identifyType(cptr, GraphNode(type->tp_name), type, baseType);
     }
-};
 
+    bool dumpTypeGraph(const char *fileName) const;
 
-#ifndef NDEBUG
-static void showWrapperMap(const WrapperMap &wrapperMap)
+private:
+    TypeCptrPair identifyType(void *cptr, const GraphNode &typeNode, PyTypeObject *type,
+                              PyTypeObject *baseType) const;
+};
+
+Graph::TypeCptrPair Graph::identifyType(void *cptr,
+                                        const GraphNode &typeNode, PyTypeObject *type,
+                                        PyTypeObject *baseType) const
 {
-    if (Py_VerboseFlag > 0) {
-        fprintf(stderr, "-------------------------------\n");
-        fprintf(stderr, "WrapperMap: %p (size: %d)\n", &wrapperMap, (int) wrapperMap.size());
-        for (auto it = wrapperMap.begin(), end = wrapperMap.end(); it != end; ++it) {
-            const SbkObject *sbkObj = it->second;
-            fprintf(stderr, "key: %p, value: %p (%s, refcnt: %d)\n", it->first,
-                    static_cast<const void *>(sbkObj),
-                    (Py_TYPE(sbkObj))->tp_name,
-                    int(reinterpret_cast<const PyObject *>(sbkObj)->ob_refcnt));
+    assert(typeNode.initStruct != nullptr || type != nullptr);
+    auto edgesIt = m_edges.find(typeNode);
+    if (edgesIt != m_edges.end()) {
+        const NodeList &adjNodes = edgesIt->second;
+        for (const auto &node : adjNodes) {
+            auto newType = identifyType(cptr, node, nullptr, baseType);
+            if (newType.first != nullptr)
+                return newType;
         }
-        fprintf(stderr, "-------------------------------\n");
     }
+
+    if (type == nullptr) {
+        if (typeNode.initStruct->type == nullptr) // Layzily create type
+            type = Shiboken::Module::get(*typeNode.initStruct);
+        else
+            type = typeNode.initStruct->type;
+    }
+
+    auto *sotp = PepType_SOTP(type);
+    if (sotp->type_discovery != nullptr) {
+        if (void *derivedCPtr = sotp->type_discovery(cptr, baseType))
+            return {type, derivedCPtr};
+    }
+    return {nullptr, nullptr};
+}
+
+static void formatDotNode(std::string_view name, std::ostream &file)
+{
+    auto lastDot = name.rfind('.');
+    file << "    \"" << name << "\" [ label=";
+    if (lastDot != std::string::npos) {
+        file << '"' << name.substr(lastDot + 1) << "\" tooltip=\""
+             << name.substr(0, lastDot) << '"';
+    } else {
+        file << '"' << name << '"';
+    }
+    file << " ]\n";
+}
+
+bool Graph::dumpTypeGraph(const char *fileName) const
+{
+    std::ofstream file(fileName);
+    if (!file.good())
+        return false;
+
+    file << "digraph D {\n";
+
+    // Define nodes with short names
+    for (const auto &node : nodeSet())
+        formatDotNode(node.name, file);
+
+    // Write edges
+    for (const auto &p : m_edges) {
+        const auto &node1 = p.first;
+        const NodeList &nodeList = p.second;
+        for (const auto &node2 : nodeList)
+            file << "    \"" << node2.name << "\" -> \"" << node1.name << "\"\n";
+    }
+    file << "}\n";
+    return true;
 }
-#endif
 
 struct BindingManager::BindingManagerPrivate {
     using DestructorEntries = std::vector<DestructorEntry>;
@@ -113,20 +174,19 @@ struct BindingManager::BindingManagerPrivate {
     std::recursive_mutex wrapperMapLock;
     Graph classHierarchy;
     DestructorEntries deleteInMainThread;
-    bool destroying;
 
-    BindingManagerPrivate() : destroying(false) {}
-    bool releaseWrapper(void *cptr, SbkObject *wrapper);
-    void assignWrapper(SbkObject *wrapper, const void *cptr);
+    bool releaseWrapper(void *cptr, SbkObject *wrapper, const int *bases = nullptr);
+    bool releaseWrapperHelper(void *cptr, SbkObject *wrapper);
 
+    void assignWrapper(SbkObject *wrapper, const void *cptr, const int *bases = nullptr);
+    void assignWrapperHelper(SbkObject *wrapper, const void *cptr);
 };
 
-bool BindingManager::BindingManagerPrivate::releaseWrapper(void *cptr, SbkObject *wrapper)
+inline bool BindingManager::BindingManagerPrivate::releaseWrapperHelper(void *cptr, SbkObject *wrapper)
 {
     // The wrapper argument is checked to ensure that the correct wrapper is released.
     // Returns true if the correct wrapper is found and released.
     // If wrapper argument is NULL, no such check is performed.
-    std::lock_guard<std::recursive_mutex> guard(wrapperMapLock);
     auto iter = wrapperMapper.find(cptr);
     if (iter != wrapperMapper.end() && (wrapper == nullptr || iter->second == wrapper)) {
         wrapperMapper.erase(iter);
@@ -135,15 +195,41 @@ bool BindingManager::BindingManagerPrivate::releaseWrapper(void *cptr, SbkObject
     return false;
 }
 
-void BindingManager::BindingManagerPrivate::assignWrapper(SbkObject *wrapper, const void *cptr)
+bool BindingManager::BindingManagerPrivate::releaseWrapper(void *cptr, SbkObject *wrapper,
+                                                           const int *bases)
 {
     assert(cptr);
     std::lock_guard<std::recursive_mutex> guard(wrapperMapLock);
+    const bool result = releaseWrapperHelper(cptr, wrapper);
+    if (bases != nullptr) {
+        auto *base = static_cast<uint8_t *>(cptr);
+        for (const auto *offset = bases; *offset != -1; ++offset)
+            releaseWrapperHelper(base + *offset, wrapper);
+    }
+    return result;
+}
+
+inline void BindingManager::BindingManagerPrivate::assignWrapperHelper(SbkObject *wrapper,
+                                                                       const void *cptr)
+{
     auto iter = wrapperMapper.find(cptr);
     if (iter == wrapperMapper.end())
         wrapperMapper.insert(std::make_pair(cptr, wrapper));
 }
 
+void BindingManager::BindingManagerPrivate::assignWrapper(SbkObject *wrapper, const void *cptr,
+                                                          const int *bases)
+{
+    assert(cptr);
+    std::lock_guard<std::recursive_mutex> guard(wrapperMapLock);
+    assignWrapperHelper(wrapper, cptr);
+    if (bases != nullptr) {
+        const auto *base = static_cast<const uint8_t *>(cptr);
+        for (const auto *offset = bases; *offset != -1; ++offset)
+            assignWrapperHelper(wrapper, base + *offset);
+    }
+}
+
 BindingManager::BindingManager()
 {
     m_d = new BindingManager::BindingManagerPrivate;
@@ -159,7 +245,8 @@ BindingManager::~BindingManager()
     debugRemoveFreeHook();
 #endif
 #ifndef NDEBUG
-    showWrapperMap(m_d->wrapperMapper);
+    if (Shiboken::pyVerbose() > 0)
+        dumpWrapperMap();
 #endif
     /* Cleanup hanging references. We just invalidate them as when
      * the BindingManager is being destroyed the interpreter is alredy
@@ -195,15 +282,7 @@ void BindingManager::registerWrapper(SbkObject *pyObj, void *cptr)
 
     if (d->mi_init && !d->mi_offsets)
         d->mi_offsets = d->mi_init(cptr);
-    m_d->assignWrapper(pyObj, cptr);
-    if (d->mi_offsets) {
-        int *offset = d->mi_offsets;
-        while (*offset != -1) {
-            if (*offset > 0)
-                m_d->assignWrapper(pyObj, reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(cptr) + *offset));
-            offset++;
-        }
-    }
+    m_d->assignWrapper(pyObj, cptr, d->mi_offsets);
 }
 
 void BindingManager::releaseWrapper(SbkObject *sbkObj)
@@ -213,17 +292,10 @@ void BindingManager::releaseWrapper(SbkObject *sbkObj)
     int numBases = ((d && d->is_multicpp) ? getNumberOfCppBaseClasses(Py_TYPE(sbkObj)) : 1);
 
     void ** cptrs = reinterpret_cast<SbkObject *>(sbkObj)->d->cptr;
+    const int *mi_offsets = d != nullptr ? d->mi_offsets : nullptr;
     for (int i = 0; i < numBases; ++i) {
-        auto *cptr = reinterpret_cast<unsigned char *>(cptrs[i]);
-        m_d->releaseWrapper(cptr, sbkObj);
-        if (d && d->mi_offsets) {
-            int *offset = d->mi_offsets;
-            while (*offset != -1) {
-                if (*offset > 0)
-                    m_d->releaseWrapper(reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(cptr) + *offset), sbkObj);
-                offset++;
-            }
-        }
+        if (cptrs[i] != nullptr)
+            m_d->releaseWrapper(cptrs[i], sbkObj, mi_offsets);
     }
     sbkObj->d->validCppObject = false;
 }
@@ -256,7 +328,7 @@ PyObject *BindingManager::getOverride(const void *cptr,
     SbkObject *wrapper = retrieveWrapper(cptr);
     // The refcount can be 0 if the object is dieing and someone called
     // a virtual method from the destructor
-    if (!wrapper || reinterpret_cast<const PyObject *>(wrapper)->ob_refcnt == 0)
+    if (!wrapper || Py_REFCNT(reinterpret_cast<const PyObject *>(wrapper)) == 0)
         return nullptr;
 
     // PYSIDE-1626: Touch the type to initiate switching early.
@@ -276,6 +348,8 @@ PyObject *BindingManager::getOverride(const void *cptr,
     auto *obWrapper = reinterpret_cast<PyObject *>(wrapper);
     auto *wrapper_dict = SbkObject_GetDict_NoRef(obWrapper);
     if (PyObject *method = PyDict_GetItem(wrapper_dict, pyMethodName)) {
+        // Note: This special case was implemented for duck-punching, which happens
+        // in the instance dict. It does not work with properties.
         Py_INCREF(method);
         return method;
     }
@@ -317,36 +391,53 @@ PyObject *BindingManager::getOverride(const void *cptr,
     }
 
     if (method != nullptr) {
-        PyObject *defaultMethod;
+        PyObject *defaultMethod{};
         PyObject *mro = Py_TYPE(wrapper)->tp_mro;
 
         int size = PyTuple_GET_SIZE(mro);
+        bool defaultFound = false;
         // The first class in the mro (index 0) is the class being checked and it should not be tested.
         // The last class in the mro (size - 1) is the base Python object class which should not be tested also.
         for (int idx = 1; idx < size - 1; ++idx) {
             auto *parent = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
-            if (parent->tp_dict) {
-                defaultMethod = PyDict_GetItem(parent->tp_dict, pyMethodName);
-                if (defaultMethod && function != defaultMethod)
-                    return method;
+            AutoDecRef tpDict(PepType_GetDict(parent));
+            auto *parentDict = tpDict.object();
+            if (parentDict) {
+                defaultMethod = PyDict_GetItem(parentDict, pyMethodName);
+                if (defaultMethod) {
+                    defaultFound = true;
+                    if (function != defaultMethod)
+                        return method;
+                }
             }
         }
-
+        // PYSIDE-2255: If no default method was found, use the method.
+        if (!defaultFound)
+            return method;
         Py_DECREF(method);
     }
 
     return nullptr;
 }
 
-void BindingManager::addClassInheritance(PyTypeObject *parent, PyTypeObject *child)
+void BindingManager::addClassInheritance(Module::TypeInitStruct *parent,
+                                         Module::TypeInitStruct *child)
 {
-    m_d->classHierarchy.addEdge(parent, child);
+    m_d->classHierarchy.addEdge(GraphNode(parent), GraphNode(child));
 }
 
+BindingManager::TypeCptrPair BindingManager::findDerivedType(void *cptr, PyTypeObject *type) const
+{
+    return m_d->classHierarchy.identifyType(cptr, type, type);
+}
+
+// FIXME PYSIDE7: remove, just for compatibility
 PyTypeObject *BindingManager::resolveType(void **cptr, PyTypeObject *type)
 {
-    PyTypeObject *identifiedType = m_d->classHierarchy.identifyType(cptr, type, type);
-    return identifiedType ? identifiedType : type;
+    auto result = findDerivedType(*cptr, type);
+    if (result.second != nullptr)
+        *cptr = result.second;
+    return result.first != nullptr ? result.first : type;
 }
 
 std::set<PyObject *> BindingManager::getAllPyObjects()
@@ -364,10 +455,94 @@ std::set<PyObject *> BindingManager::getAllPyObjects()
 void BindingManager::visitAllPyObjects(ObjectVisitor visitor, void *data)
 {
     WrapperMap copy = m_d->wrapperMapper;
-    for (auto it = copy.begin(); it != copy.end(); ++it) {
-        if (hasWrapper(it->first))
-            visitor(it->second, data);
+    for (const auto &p : copy) {
+        if (hasWrapper(p.first))
+            visitor(p.second, data);
+    }
+}
+
+bool BindingManager::dumpTypeGraph(const char *fileName) const
+{
+    return m_d->classHierarchy.dumpTypeGraph(fileName);
+}
+
+void BindingManager::dumpWrapperMap()
+{
+    const auto &wrapperMap = m_d->wrapperMapper;
+    std::cerr <<  "-------------------------------\n"
+        << "WrapperMap size: " << wrapperMap.size() << " Types: "
+        << m_d->classHierarchy.nodeSet().size() << '\n';
+    for (auto it = wrapperMap.begin(), end = wrapperMap.end(); it != end; ++it) {
+        const SbkObject *sbkObj = it->second;
+        std::cerr << "key: " << it->first << ", value: "
+            << static_cast<const void *>(sbkObj) << " ("
+            << (Py_TYPE(sbkObj))->tp_name << ", refcnt: "
+            << Py_REFCNT(reinterpret_cast<const PyObject *>(sbkObj)) << ")\n";
+    }
+    std::cerr << "-------------------------------\n";
+}
+
+static bool isPythonType(PyTypeObject *type)
+{
+    // This is a type which should be called by multiple inheritance.
+    // It is either a pure Python type or a derived PySide type.
+    return !ObjectType::checkType(type) || ObjectType::isUserType(type);
+}
+
+bool callInheritedInit(PyObject *self, PyObject *args, PyObject *kwds,
+                                       const char *fullName)
+{
+    using Shiboken::AutoDecRef;
+
+    static PyObject *const _init = String::createStaticString("__init__");
+    static PyObject *objectInit =
+        PyObject_GetAttr(reinterpret_cast<PyObject *>(&PyBaseObject_Type), _init);
+
+    // A native C++ self cannot have multiple inheritance.
+    if (!Object::isUserType(self))
+        return false;
+
+    auto *startType = Py_TYPE(self);
+    auto *mro = startType->tp_mro;
+    Py_ssize_t idx, n = PyTuple_GET_SIZE(mro);
+    auto classNameLen = std::strrchr(fullName, '.') - fullName;
+    /* No need to check the last one: it's gonna be skipped anyway.  */
+    for (idx = 0; idx + 1 < n; ++idx) {
+        auto *lookType = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        const char *lookName = lookType->tp_name;
+        auto lookLen = long(std::strlen(lookName));
+        if (std::strncmp(lookName, fullName, classNameLen) == 0 && lookLen == classNameLen)
+            break;
+    }
+    // We are now at the first non-Python class `QObject`.
+    // mro: ('C', 'A', 'QObject', 'Object', 'B', 'object')
+    // We want to catch class `B` and call its `__init__`.
+    for (idx += 1; idx + 1 < n; ++idx) {
+        auto *t = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        if (isPythonType(t))
+            break;
     }
+    if (idx >= n)
+        return false;
+
+    auto *obSubType = PyTuple_GET_ITEM(mro, idx);
+    auto *subType = reinterpret_cast<PyTypeObject *>(obSubType);
+    if (subType == &PyBaseObject_Type)
+        return false;
+    AutoDecRef func(PyObject_GetAttr(obSubType, _init));
+    // PYSIDE-2654: If this has no implementation then we get object.__init__
+    //              but that is the same case like above.
+    if (func == objectInit)
+        return false;
+    // PYSIDE-2294: We need to explicitly ignore positional args in a mixin class.
+    SBK_UNUSED(args);
+    AutoDecRef newArgs(PyTuple_New(1));
+    auto *newArgsOb = newArgs.object();
+    Py_INCREF(self);
+    PyTuple_SET_ITEM(newArgsOb, 0, self);
+    // Note: This can fail, so please always check the error status.
+    AutoDecRef result(PyObject_Call(func, newArgs, kwds));
+    return true;
 }
 
 } // namespace Shiboken
diff --git a/sources/shiboken6/libshiboken/bindingmanager.h b/sources/shiboken6/libshiboken/bindingmanager.h
index e299dad96..54c4e486a 100644
--- a/sources/shiboken6/libshiboken/bindingmanager.h
+++ b/sources/shiboken6/libshiboken/bindingmanager.h
@@ -5,17 +5,23 @@
 #define BINDINGMANAGER_H
 
 #include "sbkpython.h"
-#include <set>
 #include "shibokenmacros.h"
 
+#include <set>
+#include <utility>
+
 struct SbkObject;
 
 namespace Shiboken
 {
 
+namespace Module {
+struct TypeInitStruct;
+}
+
 struct DestructorEntry;
 
-typedef void (*ObjectVisitor)(SbkObject *, void *);
+using ObjectVisitor = void (*)(SbkObject *, void *);
 
 class LIBSHIBOKEN_API BindingManager
 {
@@ -38,7 +44,15 @@ public:
     SbkObject *retrieveWrapper(const void *cptr);
     PyObject *getOverride(const void *cptr, PyObject *nameCache[], const char *methodName);
 
-    void addClassInheritance(PyTypeObject *parent, PyTypeObject *child);
+    void addClassInheritance(Module::TypeInitStruct *parent, Module::TypeInitStruct *child);
+    /// Try to find the correct type of cptr via type discovery knowing that it's at least
+    /// of type \p type. If a derived class is found, it returns a cptr cast to the type
+    /// (which may be different in case of  multiple inheritance.
+    /// \param cptr a pointer to the instance of type \p type
+    /// \param type type of cptr
+    using TypeCptrPair = std::pair<PyTypeObject *, void *>;
+    TypeCptrPair findDerivedType(void *cptr, PyTypeObject *type) const;
+
     /**
      * Try to find the correct type of *cptr knowing that it's at least of type \p type.
      * In case of multiple inheritance this function may change the contents of cptr.
@@ -46,7 +60,7 @@ public:
      * \param type type of *cptr
      * \warning This function is slow, use it only as last resort.
      */
-    PyTypeObject *resolveType(void **cptr, PyTypeObject *type);
+    [[deprecated]] PyTypeObject *resolveType(void **cptr, PyTypeObject *type);
 
     std::set<PyObject *> getAllPyObjects();
 
@@ -59,6 +73,9 @@ public:
      */
     void visitAllPyObjects(ObjectVisitor visitor, void *data);
 
+    bool dumpTypeGraph(const char *fileName) const;
+    void dumpWrapperMap();
+
 private:
     ~BindingManager();
     BindingManager();
@@ -67,6 +84,9 @@ private:
     BindingManagerPrivate *m_d;
 };
 
+LIBSHIBOKEN_API bool callInheritedInit(PyObject *self, PyObject *args, PyObject *kwds,
+                                       const char *fullName);
+
 } // namespace Shiboken
 
 #endif // BINDINGMANAGER_H
diff --git a/sources/shiboken6/libshiboken/bufferprocs_py37.h b/sources/shiboken6/libshiboken/bufferprocs_py37.h
index 06b42cabd..e16194e50 100644
--- a/sources/shiboken6/libshiboken/bufferprocs_py37.h
+++ b/sources/shiboken6/libshiboken/bufferprocs_py37.h
@@ -67,8 +67,8 @@ typedef struct bufferinfo {
     void *internal;
 } Pep_buffer;
 
-typedef int (*getbufferproc)(PyObject *, Pep_buffer *, int);
-typedef void (*releasebufferproc)(PyObject *, Pep_buffer *);
+using getbufferproc =int (*)(PyObject *, Pep_buffer *, int);
+using releasebufferproc = void (*)(PyObject *, Pep_buffer *);
 
 /* Maximum number of dimensions */
 #define PyBUF_MAX_NDIM 64
diff --git a/sources/shiboken6/libshiboken/debugfreehook.cpp b/sources/shiboken6/libshiboken/debugfreehook.cpp
index 1a80a2514..13df6bd6c 100644
--- a/sources/shiboken6/libshiboken/debugfreehook.cpp
+++ b/sources/shiboken6/libshiboken/debugfreehook.cpp
@@ -6,8 +6,8 @@
 #include "gilstate.h"
 
 #if defined(_WIN32) && defined(_DEBUG)
-#include <crtdbg.h>
-#include <windows.h>
+#  include <sbkwindows.h>
+#  include <crtdbg.h>
 #endif
 
 #ifdef __GLIBC__
diff --git a/sources/shiboken6/libshiboken/embed/embedding_generator.py b/sources/shiboken6/libshiboken/embed/embedding_generator.py
index 96f66b949..a058fd372 100644
--- a/sources/shiboken6/libshiboken/embed/embedding_generator.py
+++ b/sources/shiboken6/libshiboken/embed/embedding_generator.py
@@ -122,22 +122,23 @@ def _embed_file(fin, fout):
     limit = 50
     text = fin.readlines()
     print(textwrap.dedent("""
-        /*
-         * This is a ZIP archive of all Python files in the directory
-         *         "shiboken6/shibokenmodule/files.dir/shibokensupport/signature"
-         * There is also a toplevel file "signature_bootstrap.py[c]" that will be
-         * directly executed from C++ as a bootstrap loader.
-         */
+         // This is a ZIP archive of all Python files in the directory
+         //         "shiboken6/shibokenmodule/files.dir/shibokensupport/signature"
+         // There is also a toplevel file "signature_bootstrap.py[c]" that will be
+         // directly executed from C++ as a bootstrap loader.
          """).strip(), file=fout)
     block, blocks = 0, len(text) // limit + 1
     for idx, line in enumerate(text):
         if idx % limit == 0:
+            if block:
+                fout.write(')"\n')
             comma = "," if block else ""
             block += 1
-            print(file=fout)
-            print(f'/* Block {block} of {blocks} */{comma}', file=fout)
-        print(f'\"{line.strip()}\"', file=fout)
-    print(f'/* Sentinel */, \"\"', file=fout)
+            fout.write(f'\n{comma} // Block {block} of {blocks}\nR"(')
+        else:
+            fout.write('\n')
+        fout.write(line.strip())
+    fout.write(')"\n\n/* Sentinel */, ""\n')
 
 
 def _embed_bytefile(fin, fout, is_text):
diff --git a/sources/shiboken6/libshiboken/embed/signature_bootstrap.py b/sources/shiboken6/libshiboken/embed/signature_bootstrap.py
index c11a0367a..37f95cd35 100644
--- a/sources/shiboken6/libshiboken/embed/signature_bootstrap.py
+++ b/sources/shiboken6/libshiboken/embed/signature_bootstrap.py
@@ -26,6 +26,7 @@ recursion_trap = 0
 import base64
 import importlib
 import io
+import os
 import sys
 import traceback
 import zipfile
@@ -61,21 +62,83 @@ def bootstrap():
             import shibokensupport
             yield
         except Exception as e:
-            print("Problem importing shibokensupport:")
-            print(f"{e.__class__.__name__}: {e}")
+            f = sys.stderr
+            print("Problem importing shibokensupport:", file=f)
+            print(f"{e.__class__.__name__}: {e}", file=f)
             traceback.print_exc()
-            print("sys.path:")
+            print("sys.path:", file=f)
             for p in sys.path:
-                print("  " + p)
-            sys.stdout.flush()
+                print("  " + p, file=f)
+            f.flush()
             sys.exit(-1)
         target.remove(support_path)
 
-    target, support_path = prepare_zipfile()
+    # Here we decide if we re-incarnate the embedded files or use embedding.
+    incarnated = find_incarnated_files()
+    if incarnated:
+        target, support_path = sys.path, os.fspath(incarnated)
+    else:
+        target, support_path = prepare_zipfile()
     with ensure_shibokensupport(target, support_path):
         from shibokensupport.signature import loader
     return loader
 
+# Newer functionality:
+# This function checks if the support directory exist and returns it.
+# If does not exist, we try to create it and return it.
+# Otherwise, we return None.
+
+def find_incarnated_files():
+    import shiboken6 as root
+    files_dir = Path(root.__file__).resolve().parent / "files.dir"
+    handle_embedding_switch(files_dir)
+    if files_dir.exists():
+        sys.path.insert(0, os.fspath(files_dir))
+        # Note: To avoid recursion problems, we need to preload the loader.
+        # But that has the side-effect that we need to delay the feature
+        # initialization until all function pointers are set.
+        # See `post_init_func` in signature_globals.cpp .
+        import shibokensupport.signature.loader
+        del sys.path[0]
+        return files_dir
+    return None
+
+
+def handle_embedding_switch(files_dir):
+    """
+    This handles the optional environment variable `SBK_EMBED`
+    if not set             : do nothing
+    if set to 0, false, no : de-virtualize the Python files
+    if set to 1, true, yes : virtualize again (delete "files.dir")
+    """
+    env_name = "SBK_EMBED"
+    env_var = os.environ.get(env_name)
+    if not env_var:
+        return
+    if env_var.lower() in ("1", "t", "true", "y", "yes"):
+        import shutil
+        shutil.rmtree(files_dir, ignore_errors=True)
+    elif env_var.lower() in ("0", "f", "false", "n", "no"):
+        reincarnate_files(files_dir)
+
+
+def reincarnate_files(files_dir):
+    target, zip = prepare_zipfile()
+    names = (_ for _ in zip.zfile.namelist() if _.endswith(".py"))
+    try:
+        # First check mkdir to get an error when we cannot write.
+        files_dir.mkdir(exist_ok=True)
+    except os.error as e:
+        print(f"SBK_EMBED=False: Warning: Cannot write into {files_dir}")
+        return None
+    try:
+        # Then check for a real error when unpacking the zip file.
+        zip.zfile.extractall(path=files_dir, members=names)
+        return files_dir
+    except Exception as e:
+        print(f"{e.__class__.__name__}: {e}", file=sys.stderr)
+        traceback.print_exc()
+        raise
 
 # New functionality: Loading from a zip archive.
 # There exists the zip importer, but as it is written, only real zip files are
diff --git a/sources/shiboken6/libshiboken/helper.cpp b/sources/shiboken6/libshiboken/helper.cpp
index 8f836316e..46af68956 100644
--- a/sources/shiboken6/libshiboken/helper.cpp
+++ b/sources/shiboken6/libshiboken/helper.cpp
@@ -5,28 +5,60 @@
 #include "basewrapper_p.h"
 #include "sbkstring.h"
 #include "sbkstaticstrings.h"
+#include "sbkstaticstrings.h"
+#include "pep384impl.h"
+
+#include <algorithm>
+#include <optional>
 
 #include <iomanip>
 #include <iostream>
-
+#include <climits>
+#include <cstring>
 #include <cstdarg>
+#include <cctype>
 
 #ifdef _WIN32
-#  ifndef NOMINMAX
-#    define NOMINMAX
-#  endif
-#  include <windows.h>
+#  include <sbkwindows.h>
 #else
 #  include <pthread.h>
 #endif
 
-#include <algorithm>
+static std::optional<std::string> getStringAttr(PyObject *obj, const char *what)
+{
+    if (PyObject_HasAttrString(obj, what) != 0) { // Check first to suppress error.
+        Shiboken::AutoDecRef result(PyObject_GetAttrString(obj, what));
+        if (PyUnicode_Check(result.object()) != 0)
+            return _PepUnicode_AsString(result.object());
+    }
+    return std::nullopt;
+}
 
-static void formatPyTypeObject(const PyTypeObject *obj, std::ostream &str)
+static std::optional<int> getIntAttr(PyObject *obj, const char *what)
 {
-    if (obj) {
-        str << '"' << obj->tp_name << "\", 0x" << std::hex
-            << obj->tp_flags << std::dec;
+    if (PyObject_HasAttrString(obj, what) != 0) { // Check first to suppress error.
+        Shiboken::AutoDecRef result(PyObject_GetAttrString(obj, what));
+        if (PyLong_Check(result.object()) != 0)
+            return PyLong_AsLong(result.object());
+    }
+    return std::nullopt;
+}
+
+static bool verbose = false;
+
+static void formatTypeTuple(PyObject *t, const char *what, std::ostream &str);
+
+static void formatPyTypeObject(const PyTypeObject *obj, std::ostream &str, bool verbose)
+{
+    if (obj == nullptr) {
+        str << '0';
+        return;
+    }
+
+    str << '"' << obj->tp_name << '"';
+    if (verbose) {
+        bool immutableType = false;
+        str << ", 0x" << std::hex << obj->tp_flags << std::dec;
         if (obj->tp_flags & Py_TPFLAGS_HEAPTYPE)
             str << " [heaptype]";
         if (obj->tp_flags & Py_TPFLAGS_BASETYPE)
@@ -49,30 +81,59 @@ static void formatPyTypeObject(const PyTypeObject *obj, std::ostream &str)
             str << " [type]";
         if (obj->tp_flags & Py_TPFLAGS_IS_ABSTRACT)
             str << " [abstract]";
-#if PY_VERSION_HEX >= 0x03080000
+        if (obj->tp_flags & Py_TPFLAGS_READY)
+            str << " [ready]";
+        if (obj->tp_flags & Py_TPFLAGS_READYING)
+            str << " [readying]";
         if (obj->tp_flags & Py_TPFLAGS_METHOD_DESCRIPTOR)
             str << " [method_descriptor]";
-#  if PY_VERSION_HEX >= 0x03090000
-#    ifndef Py_LIMITED_API
+#  ifndef Py_LIMITED_API
         if (obj->tp_flags & Py_TPFLAGS_HAVE_VECTORCALL)
             str << " [vectorcall]";
-#    endif // !Py_LIMITED_API
-#    if PY_VERSION_HEX >= 0x030A0000
-        if (obj->tp_flags & Py_TPFLAGS_IMMUTABLETYPE)
+#  endif // !Py_LIMITED_API
+#  if PY_VERSION_HEX >= 0x030A0000
+        immutableType = (obj->tp_flags & Py_TPFLAGS_IMMUTABLETYPE) != 0;
+        if (immutableType)
             str << " [immutabletype]";
         if (obj->tp_flags & Py_TPFLAGS_DISALLOW_INSTANTIATION)
             str << " [disallow_instantiation]";
-#      ifndef Py_LIMITED_API
+#  ifndef Py_LIMITED_API
         if (obj->tp_flags & Py_TPFLAGS_MAPPING)
             str << " [mapping]";
         if (obj->tp_flags & Py_TPFLAGS_SEQUENCE)
             str << " [sequence]";
 #       endif // !Py_LIMITED_API
-#    endif // 3.10
-#  endif // 3.9
-#endif // 3.8
-    } else {
-        str << '0';
+#  endif // 3.10
+        if (obj->tp_basicsize != 0)
+            str << ", basicsize=" << obj->tp_basicsize;
+        if (verbose) {
+            formatTypeTuple(obj->tp_bases, "bases", str);
+            formatTypeTuple(obj->tp_mro, "mro", str);
+            if (!immutableType) {
+                auto *underlying = reinterpret_cast<const PyObject *>(obj)->ob_type;
+                if (underlying != nullptr && underlying != obj) {
+                    str << ", underlying=\"" << underlying->tp_name << '"';
+                }
+            }
+        }
+    }
+}
+
+static void formatTypeTuple(PyObject *t, const char *what, std::ostream &str)
+{
+    const Py_ssize_t size = t != nullptr && PyTuple_Check(t) != 0 ? PyTuple_Size(t) : 0;
+    if (size > 0) {
+        str << ", " << what << "=[" << size << "]{";
+        for (Py_ssize_t i = 0; i < size; ++i) {
+            if (i != 0)
+                str << ", ";
+            Shiboken::AutoDecRef item(PyTuple_GetItem(t, i));
+            if (item.isNull())
+                str << '0'; // Observed with non-ready types
+            else
+                str << '"' << reinterpret_cast<PyTypeObject *>(item.object())->tp_name << '"';
+        }
+        str << '}';
     }
 }
 
@@ -151,13 +212,17 @@ static void formatPyUnicode(PyObject *obj, std::ostream &str)
 {
     // Note: The below call create the PyCompactUnicodeObject.utf8 representation
     str << '"' << _PepUnicode_AsString(obj) << '"';
+    if (!verbose)
+        return;
 
     str << " (" << PyUnicode_GetLength(obj) << ')';
     const auto kind = _PepUnicode_KIND(obj);
     switch (kind) {
+#if PY_VERSION_HEX < 0x030C0000
     case PepUnicode_WCHAR_KIND:
         str << " [wchar]";
         break;
+#endif
     case PepUnicode_1BYTE_KIND:
         str << " [1byte]";
         break;
@@ -178,8 +243,10 @@ static void formatPyUnicode(PyObject *obj, std::ostream &str)
     void *data =_PepUnicode_DATA(obj);
     str << ", data=";
     switch (kind) {
+#if PY_VERSION_HEX < 0x030C0000
     case PepUnicode_WCHAR_KIND:
         formatCharSequence(reinterpret_cast<const wchar_t *>(data), str);
+#endif
         break;
     case PepUnicode_1BYTE_KIND:
         formatCharSequence(reinterpret_cast<const Py_UCS1 *>(data), str);
@@ -208,22 +275,92 @@ static void formatPyUnicode(PyObject *obj, std::ostream &str)
 #endif // !Py_LIMITED_API
 }
 
+static std::string getQualName(PyObject *obj)
+{
+    Shiboken::AutoDecRef result(PyObject_GetAttr(obj, Shiboken::PyMagicName::qualname()));
+    return result.object() != nullptr
+        ? _PepUnicode_AsString(result.object()) : std::string{};
+}
+
+static void formatPyFunction(PyObject *obj, std::ostream &str)
+{
+    str << '"' << getQualName(obj) << "()\"";
+}
+
+static void formatPyMethod(PyObject *obj, std::ostream &str)
+{
+    if (auto *func = PyMethod_Function(obj))
+        formatPyFunction(func, str);
+    str << ", instance=" << PyMethod_Self(obj);
+}
+
+static void formatPyCodeObject(PyObject *obj, std::ostream &str)
+{
+    if (auto name = getStringAttr(obj, "co_name"))
+        str << '"' << name.value() << '"';
+    if (auto qualName = getStringAttr(obj, "co_qualname"))
+        str << ", co_qualname=\"" << qualName.value() << '"';
+    if (auto flags = getIntAttr(obj, "co_flags"))
+        str << ", flags=0x" << std::hex << flags.value() << std::dec;
+    if (auto c = getIntAttr(obj, "co_argcount"))
+        str << ", co_argcounts=" << c.value();
+    if (auto c = getIntAttr(obj, "co_posonlyargcount"))
+        str << ", co_posonlyargcount=" << c.value();
+    if (auto c = getIntAttr(obj, "co_kwonlyargcount"))
+        str << ", co_kwonlyargcount=" << c.value();
+    if (auto fileName = getStringAttr(obj, "co_filename")) {
+        str << " @" << fileName.value();
+        if (auto l = getIntAttr(obj, "co_firstlineno"))
+            str << ':'<< l.value();
+    }
+}
+
 static void formatPyObjectHelper(PyObject *obj, std::ostream &str)
 {
-    str << ", refs=" << obj->ob_refcnt << ", ";
+    str << ", ";
+    if (obj == Py_None) {
+        str << "None";
+        return;
+    }
+    if (obj == Py_True) {
+        str << "True";
+        return;
+    }
+    if (obj == Py_False) {
+        str << "False";
+        return;
+    }
+    const auto refs = Py_REFCNT(obj);
+    if (refs == UINT_MAX) // _Py_IMMORTAL_REFCNT
+        str << "immortal, ";
+    else
+        str << "refs=" << refs << ", ";
     if (PyType_Check(obj)) {
         str << "type: ";
-        formatPyTypeObject(reinterpret_cast<PyTypeObject *>(obj), str);
+        formatPyTypeObject(reinterpret_cast<PyTypeObject *>(obj), str, true);
         return;
     }
-    formatPyTypeObject(obj->ob_type, str);
+    formatPyTypeObject(obj->ob_type, str, false);
     str << ", ";
-    if (PyLong_Check(obj))
-        str << PyLong_AsLong(obj);
+    if (PyLong_Check(obj)) {
+        const auto llv = PyLong_AsLongLong(obj);
+        if (PyErr_Occurred() != PyExc_OverflowError) {
+            str << llv;
+        } else {
+            PyErr_Clear();
+            str << "0x" << std::hex << PyLong_AsUnsignedLongLong(obj) << std::dec;
+        }
+    }
     else if (PyFloat_Check(obj))
         str << PyFloat_AsDouble(obj);
     else if (PyUnicode_Check(obj))
         formatPyUnicode(obj, str);
+    else if (PyFunction_Check(obj) != 0)
+        formatPyFunction(obj, str);
+    else if (PyMethod_Check(obj) != 0)
+        formatPyMethod(obj, str);
+    else if (PepCode_Check(obj) != 0)
+        formatPyCodeObject(obj, str);
     else if (PySequence_Check(obj))
         formatPySequence(obj, str);
     else if (PyDict_Check(obj))
@@ -263,7 +400,7 @@ debugPyBuffer::debugPyBuffer(const Py_buffer &b) : m_buffer(b)
 std::ostream &operator<<(std::ostream &str, const debugPyTypeObject &o)
 {
     str << "PyTypeObject(";
-    formatPyTypeObject(o.m_object, str);
+    formatPyTypeObject(o.m_object, str, true);
     str << ')';
     return str;
 }
@@ -299,6 +436,18 @@ std::ostream &operator<<(std::ostream &str, const debugPyBuffer &b)
     return str;
 }
 
+std::ios_base &debugVerbose(std::ios_base &s)
+{
+    verbose = true;
+    return s;
+}
+
+std::ios_base &debugBrief(std::ios_base &s)
+{
+    verbose = false;
+    return s;
+}
+
 #ifdef _WIN32
 // Converts a Unicode string to a string encoded in the Windows console's
 // code page via wchar_t for use with argv (PYSIDE-1425).
@@ -442,4 +591,47 @@ ThreadId mainThreadId()
     return _mainThreadId;
 }
 
+const char *typeNameOf(const char *typeIdName)
+{
+    auto size = std::strlen(typeIdName);
+#if defined(Q_CC_MSVC) // MSVC: "class QPaintDevice * __ptr64"
+    if (auto *lastStar = strchr(typeName, '*')) {
+        // MSVC: "class QPaintDevice * __ptr64"
+        while (*--lastStar == ' ') {
+        }
+        size = lastStar - typeName + 1;
+    }
+#else // g++, Clang: "QPaintDevice *" -> "P12QPaintDevice"
+    if (size > 2 && typeIdName[0] == 'P' && std::isdigit(typeIdName[1])) {
+        ++typeIdName;
+        --size;
+    }
+#endif
+    char *result = new char[size + 1];
+    result[size] = '\0';
+    std::memcpy(result, typeIdName, size);
+    return result;
+}
+
+#if !defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030A0000 && !defined(PYPY_VERSION)
+static int _getPyVerbose()
+{
+    PyConfig config;
+    PyConfig_InitPythonConfig(&config);
+    return config.verbose;
+}
+#endif // !Py_LIMITED_API >= 3.10
+
+int pyVerbose()
+{
+#ifdef Py_LIMITED_API
+    return Pep_GetVerboseFlag();
+#elif PY_VERSION_HEX >= 0x030A0000 && !defined(PYPY_VERSION)
+    static const int result = _getPyVerbose();
+    return result;
+#else
+    return Py_VerboseFlag;
+#endif
+}
+
 } // namespace Shiboken
diff --git a/sources/shiboken6/libshiboken/helper.h b/sources/shiboken6/libshiboken/helper.h
index 265bb6581..f226e8c24 100644
--- a/sources/shiboken6/libshiboken/helper.h
+++ b/sources/shiboken6/libshiboken/helper.h
@@ -36,6 +36,10 @@ LIBSHIBOKEN_API bool listToArgcArgv(PyObject *argList, int *argc, char ***argv,
  */
 LIBSHIBOKEN_API int *sequenceToIntArray(PyObject *obj, bool zeroTerminated = false);
 
+/// Fix a type name returned by typeid(t).name(), depending on compiler.
+/// \returns Fixed name (allocated).
+LIBSHIBOKEN_API const char *typeNameOf(const char *typeIdName);
+
 /**
  *  Creates and automatically deallocates C++ arrays.
  */
@@ -61,6 +65,8 @@ using ThreadId = unsigned long long;
 LIBSHIBOKEN_API ThreadId currentThreadId();
 LIBSHIBOKEN_API ThreadId mainThreadId();
 
+LIBSHIBOKEN_API int pyVerbose();
+
 /**
  * An utility function used to call PyErr_WarnEx with a formatted message.
  */
@@ -106,7 +112,8 @@ LIBSHIBOKEN_API std::ostream &operator<<(std::ostream &str, const debugSbkObject
 LIBSHIBOKEN_API std::ostream &operator<<(std::ostream &str, const debugPyTypeObject &o);
 LIBSHIBOKEN_API std::ostream &operator<<(std::ostream &str, const debugPyBuffer &b);
 LIBSHIBOKEN_API std::ostream &operator<<(std::ostream &str, const debugPyArrayObject &b);
-
+LIBSHIBOKEN_API std::ios_base &debugVerbose(std::ios_base &s);
+LIBSHIBOKEN_API std::ios_base &debugBrief(std::ios_base &s);
 } // namespace Shiboken
 
 
diff --git a/sources/shiboken6/libshiboken/pep384_issue33738.cpp b/sources/shiboken6/libshiboken/pep384_issue33738.cpp
deleted file mode 100644
index 7f3872a58..000000000
--- a/sources/shiboken6/libshiboken/pep384_issue33738.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-// 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
-
-// There is a bug in Python 3.6 that turned the Index_Check function
-// into a macro without taking care of the limited API.
-// This leads to the single problem that we don't have
-// access to PyLong_Type's nb_index field which is no heap type.
-// We cannot easily create this function by inheritance since it is
-// not inherited.
-//
-// Simple solution: Create the structure and write such a function.
-// Long term: Submit a patch to python.org .
-
-// This structure comes from Python 3.7, but we have checked that
-// it also works for Python 3.8 and 3.9.
-
-typedef struct {
-    /* Number implementations must check *both*
-       arguments for proper type and implement the necessary conversions
-       in the slot functions themselves. */
-
-    binaryfunc nb_add;
-    binaryfunc nb_subtract;
-    binaryfunc nb_multiply;
-    binaryfunc nb_remainder;
-    binaryfunc nb_divmod;
-    ternaryfunc nb_power;
-    unaryfunc nb_negative;
-    unaryfunc nb_positive;
-    unaryfunc nb_absolute;
-    inquiry nb_bool;
-    unaryfunc nb_invert;
-    binaryfunc nb_lshift;
-    binaryfunc nb_rshift;
-    binaryfunc nb_and;
-    binaryfunc nb_xor;
-    binaryfunc nb_or;
-    unaryfunc nb_int;
-    void *nb_reserved;  /* the slot formerly known as nb_long */
-    unaryfunc nb_float;
-
-    binaryfunc nb_inplace_add;
-    binaryfunc nb_inplace_subtract;
-    binaryfunc nb_inplace_multiply;
-    binaryfunc nb_inplace_remainder;
-    ternaryfunc nb_inplace_power;
-    binaryfunc nb_inplace_lshift;
-    binaryfunc nb_inplace_rshift;
-    binaryfunc nb_inplace_and;
-    binaryfunc nb_inplace_xor;
-    binaryfunc nb_inplace_or;
-
-    binaryfunc nb_floor_divide;
-    binaryfunc nb_true_divide;
-    binaryfunc nb_inplace_floor_divide;
-    binaryfunc nb_inplace_true_divide;
-
-    unaryfunc nb_index;
-
-    binaryfunc nb_matrix_multiply;
-    binaryfunc nb_inplace_matrix_multiply;
-} PyNumberMethods;
-
-// temporary structure until we have a generator for the offsets
-typedef struct _oldtypeobject {
-    PyVarObject ob_base;
-    void *X01; // const char *tp_name;
-    void *X02; // Py_ssize_t tp_basicsize;
-    void *X03; // Py_ssize_t tp_itemsize;
-    void *X04; // destructor tp_dealloc;
-    void *X05; // printfunc tp_print;
-    void *X06; // getattrfunc tp_getattr;
-    void *X07; // setattrfunc tp_setattr;
-    void *X08; // PyAsyncMethods *tp_as_async;
-    void *X09; // reprfunc tp_repr;
-    PyNumberMethods *tp_as_number;
-
-} PyOldTypeObject;
-
-static bool is_compatible_version()
-{
-    auto *sysmodule = PyImport_AddModule("sys");
-    auto *dic = PyModule_GetDict(sysmodule);
-    auto *version = PyDict_GetItemString(dic, "version_info");
-    auto *major = PyTuple_GetItem(version, 0);
-    auto *minor = PyTuple_GetItem(version, 1);
-    auto number = PyLong_AsLong(major) * 1000 + PyLong_AsLong(minor);
-    return number < 3010;
-}
-
-///////////////////////////////////////////////////////////////////////
-//
-// PYSIE-1797: The Solution
-// ========================
-//
-// Inspecting the data structures of Python 3.6, 3.7, 3.8 and 3.9
-// shows that concerning the here needed offset of nb_index, they
-// are all compatible.
-// That means: We can use the above definition for all these versions.
-//
-// From Python 3.10 on, the `PyType_GetSlot` function also works with
-// non-heap types. That means this solution will always work.
-//
-// Note: When we have moved to Python 3.8 as the minimum version,
-// this whole nonsense can be trashed.
-// There is an automatic warning about this in parser.py .
-//
-
-LIBSHIBOKEN_API int PepIndex_Check(PyObject *obj)
-{
-    static bool old_python_version = is_compatible_version();
-    if (old_python_version) {
-        auto *type = reinterpret_cast<PyOldTypeObject *>(Py_TYPE(obj));
-        return type->tp_as_number != nullptr &&
-               type->tp_as_number->nb_index != nullptr;
-    }
-    // From Python 3.10 on, we can use PyType_GetSlot also with normal types!
-    unaryfunc nb_index = reinterpret_cast<unaryfunc>(PyType_GetSlot(Py_TYPE(obj), Py_nb_index));
-    return nb_index != nullptr;
-}
-
diff --git a/sources/shiboken6/libshiboken/pep384ext.h b/sources/shiboken6/libshiboken/pep384ext.h
new file mode 100644
index 000000000..021c53d16
--- /dev/null
+++ b/sources/shiboken6/libshiboken/pep384ext.h
@@ -0,0 +1,89 @@
+// 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 PEP384EXT_H
+#define PEP384EXT_H
+
+#include "pep384impl.h"
+
+/// Returns the allocator slot of the PyTypeObject.
+inline allocfunc PepExt_Type_GetAllocSlot(PyTypeObject *t)
+{
+    return reinterpret_cast<allocfunc>(PepType_GetSlot(t, Py_tp_alloc));
+}
+
+/// Invokes the allocator slot of the PyTypeObject.
+template <class Type>
+inline Type *PepExt_TypeCallAlloc(PyTypeObject *t, Py_ssize_t nitems)
+{
+    PyObject *result = PepExt_Type_GetAllocSlot(t)(t, nitems);
+    return reinterpret_cast<Type *>(result);
+}
+
+/// Returns the getattro slot of the PyTypeObject.
+inline getattrofunc PepExt_Type_GetGetAttroSlot(PyTypeObject *t)
+{
+    return reinterpret_cast<getattrofunc>(PepType_GetSlot(t, Py_tp_getattro));
+}
+
+/// Returns the setattro slot of the PyTypeObject.
+inline setattrofunc PepExt_Type_GetSetAttroSlot(PyTypeObject *t)
+{
+    return reinterpret_cast<setattrofunc>(PepType_GetSlot(t, Py_tp_setattro));
+}
+
+/// Returns the descr_get slot of the PyTypeObject.
+inline descrgetfunc PepExt_Type_GetDescrGetSlot(PyTypeObject *t)
+{
+    return reinterpret_cast<descrgetfunc>(PepType_GetSlot(t, Py_tp_descr_get));
+}
+
+/// Invokes the descr_get slot of the PyTypeObject.
+inline PyObject *PepExt_Type_CallDescrGet(PyObject *self, PyObject *obj, PyObject *type)
+{
+    return PepExt_Type_GetDescrGetSlot(Py_TYPE(self))(self, obj, type);
+}
+
+/// Returns the descr_set slot of the PyTypeObject.
+inline descrsetfunc PepExt_Type_GetDescrSetSlot(PyTypeObject *t)
+{
+    return reinterpret_cast<descrsetfunc>(PepType_GetSlot(t, Py_tp_descr_set));
+}
+
+/// Returns the call slot of the PyTypeObject.
+inline ternaryfunc PepExt_Type_GetCallSlot(PyTypeObject *t)
+{
+    return reinterpret_cast<ternaryfunc>(PepType_GetSlot(t, Py_tp_call));
+}
+
+/// Returns the new slot of the PyTypeObject.
+inline newfunc PepExt_Type_GetNewSlot(PyTypeObject *t)
+{
+    return reinterpret_cast<newfunc>(PepType_GetSlot(t, Py_tp_new));
+}
+
+/// Returns the init slot of the PyTypeObject.
+inline initproc PepExt_Type_GetInitSlot(PyTypeObject *t)
+{
+    return reinterpret_cast<initproc>(PepType_GetSlot(t, Py_tp_init));
+}
+
+/// Returns the free slot of the PyTypeObject.
+inline freefunc PepExt_Type_GetFreeSlot(PyTypeObject *t)
+{
+    return reinterpret_cast<freefunc>(PepType_GetSlot(t, Py_tp_free));
+}
+
+/// Invokes the free slot of the PyTypeObject.
+inline void PepExt_TypeCallFree(PyTypeObject *t, void *object)
+{
+    PepExt_Type_GetFreeSlot(t)(object);
+}
+
+/// Invokes the free slot of the PyTypeObject.
+inline void PepExt_TypeCallFree(PyObject *object)
+{
+    PepExt_Type_GetFreeSlot(Py_TYPE(object))(object);
+}
+
+#endif // PEP384EXT_H
diff --git a/sources/shiboken6/libshiboken/pep384impl.cpp b/sources/shiboken6/libshiboken/pep384impl.cpp
index 3a9a60f74..5310207a3 100644
--- a/sources/shiboken6/libshiboken/pep384impl.cpp
+++ b/sources/shiboken6/libshiboken/pep384impl.cpp
@@ -1,6 +1,8 @@
-// Copyright (C) 2018 The Qt Company Ltd.
+// 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
 
+#define PEP384_INTERN
+
 #include "sbkpython.h"
 #include "autodecref.h"
 #include "sbkstaticstrings.h"
@@ -8,8 +10,6 @@
 #include "basewrapper.h"
 #include "basewrapper_p.h"
 #include "sbkenum.h"
-#include "sbkenum_p.h"
-#include "sbkconverter.h"
 #include "voidptr.h"
 
 #include <cstdlib>
@@ -19,7 +19,7 @@ extern "C"
 {
 
 /*
- * The documentation is located in pep384impl_doc.rst
+ * The documentation is located in `sources/pyside6/doc/developer/limited_api.rst`.
 
  * Here is the verification code for PyTypeObject.
  * We create a type object and check if its fields
@@ -105,18 +105,20 @@ static PyType_Spec typeprobe_spec = {
 static void
 check_PyTypeObject_valid()
 {
-    auto *obtype = reinterpret_cast<PyObject *>(&PyType_Type);
-    auto *probe_tp_base = reinterpret_cast<PyTypeObject *>(
-        PyObject_GetAttr(obtype, Shiboken::PyMagicName::base()));
+    auto *typetype = &PyType_Type;
+    auto *obtype = reinterpret_cast<PyObject *>(typetype);
+    auto *probe_tp_base_obj = PyObject_GetAttr(obtype, Shiboken::PyMagicName::base());
+    auto *probe_tp_base = reinterpret_cast<PyTypeObject *>(probe_tp_base_obj);
     auto *probe_tp_bases = PyObject_GetAttr(obtype, Shiboken::PyMagicName::bases());
-    auto *check = reinterpret_cast<PyTypeObject *>(
-        PyType_FromSpecWithBases(&typeprobe_spec, probe_tp_bases));
-    auto *typetype = reinterpret_cast<PyTypeObject *>(obtype);
+    auto *checkObj = PyType_FromSpecWithBases(&typeprobe_spec, probe_tp_bases);
+    auto *check = reinterpret_cast<PyTypeObject *>(checkObj);
     PyObject *w = PyObject_GetAttr(obtype, Shiboken::PyMagicName::weakrefoffset());
     long probe_tp_weakrefoffset = PyLong_AsLong(w);
     PyObject *d = PyObject_GetAttr(obtype, Shiboken::PyMagicName::dictoffset());
     long probe_tp_dictoffset = PyLong_AsLong(d);
     PyObject *probe_tp_mro = PyObject_GetAttr(obtype, Shiboken::PyMagicName::mro());
+    Shiboken::AutoDecRef tpDict(PepType_GetDict(check));
+    auto *checkDict = tpDict.object();
     if (false
         || strcmp(probe_tp_name, check->tp_name) != 0
         || probe_tp_basicsize       != check->tp_basicsize
@@ -133,8 +135,8 @@ check_PyTypeObject_valid()
         || probe_tp_methods         != check->tp_methods
         || probe_tp_getset          != check->tp_getset
         || probe_tp_base            != typetype->tp_base
-        || !PyDict_Check(check->tp_dict)
-        || !PyDict_GetItemString(check->tp_dict, "dummy")
+        || !PyDict_Check(checkDict)
+        || !PyDict_GetItemString(checkDict, "dummy")
         || probe_tp_descr_get       != check->tp_descr_get
         || probe_tp_descr_set       != check->tp_descr_set
         || probe_tp_dictoffset      != typetype->tp_dictoffset
@@ -147,17 +149,14 @@ check_PyTypeObject_valid()
         || probe_tp_mro             != typetype->tp_mro
         || Py_TPFLAGS_DEFAULT       != (check->tp_flags & Py_TPFLAGS_DEFAULT))
         Py_FatalError("The structure of type objects has changed!");
-    Py_DECREF(check);
-    Py_DECREF(probe_tp_base);
+    Py_DECREF(checkObj);
+    Py_DECREF(probe_tp_base_obj);
     Py_DECREF(w);
     Py_DECREF(d);
     Py_DECREF(probe_tp_bases);
     Py_DECREF(probe_tp_mro);
 }
 
-// PYSIDE-1797: This must be a runtime decision.
-#include "pep384_issue33738.cpp"
-
 #endif // Py_LIMITED_API
 
 /*****************************************************************************
@@ -179,7 +178,7 @@ static PyObject *
 find_name_in_mro(PyTypeObject *type, PyObject *name, int *error)
 {
     Py_ssize_t i, n;
-    PyObject *mro, *res, *base, *dict;
+    PyObject *mro, *res, *base;
 
     /* Look in tp_dict of types in MRO */
     mro = type->tp_mro;
@@ -193,9 +192,10 @@ find_name_in_mro(PyTypeObject *type, PyObject *name, int *error)
     for (i = 0; i < n; i++) {
         base = PyTuple_GET_ITEM(mro, i);
         assert(PyType_Check(base));
-        dict = ((PyTypeObject *)base)->tp_dict;
-        assert(dict && PyDict_Check(dict));
-        res = PyDict_GetItem(dict, name);
+        auto *type = reinterpret_cast<PyTypeObject *>(base);
+        Shiboken::AutoDecRef dict(PepType_GetDict(type));
+        assert(!dict.isNull() && PyDict_Check(dict.object()));
+        res = PyDict_GetItem(dict.object(), name);
         if (res != nullptr)
             break;
         if (PyErr_Occurred()) {
@@ -251,7 +251,7 @@ _PepType_Lookup(PyTypeObject *type, PyObject *name)
 // structs and macros modelled after their equivalents in
 // cpython/Include/cpython/unicodeobject.h
 
-struct PepASCIIObject
+struct PepASCIIObject // since 3.12
 {
     PyObject_HEAD
     Py_ssize_t length;          /* Number of code points in the string */
@@ -264,18 +264,29 @@ struct PepASCIIObject
         unsigned int ready:1;
         unsigned int :24;
     } state;
+};
+
+struct PepASCIIObject_311 : public PepASCIIObject
+{
     wchar_t *wstr;              /* wchar_t representation (null-terminated) */
 };
 
-struct PepCompactUnicodeObject
+struct PepCompactUnicodeObject // since 3.12
 {
     PepASCIIObject _base;
     Py_ssize_t utf8_length;
     char *utf8;                 /* UTF-8 representation (null-terminated) */
+};
+
+struct PepCompactUnicodeObject_311 // since 3.12
+{
+    PepASCIIObject_311 _base;
+    Py_ssize_t utf8_length;
+    char *utf8;                 /* UTF-8 representation (null-terminated) */
     Py_ssize_t wstr_length;     /* Number of code points in wstr */
 };
 
-struct PepUnicodeObject
+struct PepUnicodeObject // since 3.12
 {
     PepCompactUnicodeObject _base;
     union {
@@ -286,6 +297,17 @@ struct PepUnicodeObject
     } data;                     /* Canonical, smallest-form Unicode buffer */
 };
 
+struct PepUnicodeObject_311
+{
+    PepCompactUnicodeObject_311 _base;
+    union {
+        void *any;
+        Py_UCS1 *latin1;
+        Py_UCS2 *ucs2;
+        Py_UCS4 *ucs4;
+    } data;                     /* Canonical, smallest-form Unicode buffer */
+};
+
 int _PepUnicode_KIND(PyObject *str)
 {
     return reinterpret_cast<PepASCIIObject *>(str)->state.kind;
@@ -303,18 +325,33 @@ int _PepUnicode_IS_COMPACT(PyObject *str)
     return asciiObj->state.compact;
 }
 
-static void *_PepUnicode_COMPACT_DATA(PyObject *str)
+static void *_PepUnicode_ASCII_DATA(PyObject *str)
 {
+    if (_PepRuntimeVersion() < 0x030C00) {
+        auto *asciiObj_311 = reinterpret_cast<PepASCIIObject_311 *>(str);
+        return asciiObj_311 + 1;
+    }
     auto *asciiObj = reinterpret_cast<PepASCIIObject *>(str);
-    if (asciiObj->state.ascii)
-        return asciiObj + 1;
+    return asciiObj + 1;
+}
+
+static void *_PepUnicode_COMPACT_DATA(PyObject *str)
+{
+    if (_PepUnicode_IS_ASCII(str) != 0)
+        return _PepUnicode_ASCII_DATA(str);
+    if (_PepRuntimeVersion() < 0x030C00) {
+        auto *compactObj_311 = reinterpret_cast<PepCompactUnicodeObject_311 *>(str);
+        return compactObj_311 + 1;
+    }
     auto *compactObj = reinterpret_cast<PepCompactUnicodeObject *>(str);
     return compactObj + 1;
 }
 
 static void *_PepUnicode_NONCOMPACT_DATA(PyObject *str)
 {
-    return reinterpret_cast<PepUnicodeObject *>(str)->data.any;
+    return _PepRuntimeVersion() < 0x030C00
+        ? reinterpret_cast<PepUnicodeObject_311 *>(str)->data.any
+        : reinterpret_cast<PepUnicodeObject *>(str)->data.any;
 }
 
 void *_PepUnicode_DATA(PyObject *str)
@@ -325,6 +362,23 @@ void *_PepUnicode_DATA(PyObject *str)
 
 // Fast path accessing UTF8 data without doing a conversion similar
 // to _PyUnicode_AsUTF8String
+static const char *utf8FastPath_311(PyObject *str)
+{
+    if (PyUnicode_GetLength(str) == 0)
+        return "";
+    auto *asciiObj = reinterpret_cast<PepASCIIObject_311 *>(str);
+    if (asciiObj->state.kind != PepUnicode_1BYTE_KIND || asciiObj->state.compact == 0)
+        return nullptr; // Empirical: PyCompactUnicodeObject.utf8 is only valid for 1 byte
+    if (asciiObj->state.ascii) {
+        auto *data = asciiObj + 1;
+        return reinterpret_cast<const char *>(data);
+    }
+    auto *compactObj = reinterpret_cast<PepCompactUnicodeObject_311 *>(str);
+    if (compactObj->utf8_length)
+        return compactObj->utf8;
+    return nullptr;
+}
+
 static const char *utf8FastPath(PyObject *str)
 {
     if (PyUnicode_GetLength(str) == 0)
@@ -356,8 +410,10 @@ const char *_PepUnicode_AsString(PyObject *str)
 #define TOSTRING(x) STRINGIFY(x)
 #define AT __FILE__ ":" TOSTRING(__LINE__)
 
-    if (const auto *utf8 = utf8FastPath(str))
+    if (const auto *utf8 = _PepRuntimeVersion() < 0x030C00
+        ? utf8FastPath_311(str) : utf8FastPath(str)) {
         return utf8;
+    }
 
     static PyObject *cstring_dict = nullptr;
     if (cstring_dict == nullptr) {
@@ -426,6 +482,47 @@ Pep_GetVerboseFlag()
 }
 #endif // Py_LIMITED_API
 
+// Support for pyerrors.h
+
+#if defined(Py_LIMITED_API) || PY_VERSION_HEX < 0x030C0000
+// Emulate PyErr_GetRaisedException() using the deprecated PyErr_Fetch()/PyErr_Store()
+PyObject *PepErr_GetRaisedException()
+{
+    PyObject *type{};
+    PyObject *value{};
+    PyObject *traceback{};
+    PyErr_Fetch(&type, &value, &traceback);
+    Py_XINCREF(value);
+    PyErr_Restore(type, value, traceback);
+    return value;
+}
+
+struct PepException_HEAD
+{
+    PyObject_HEAD
+    PyObject *x1; // dict
+    PyObject *args;
+};
+
+// PyException_GetArgs/PyException_SetArgs were added to the stable API in 3.12
+PyObject *PepException_GetArgs(PyObject *ex)
+{
+    auto *h = reinterpret_cast<PepException_HEAD *>(ex);
+    Py_XINCREF(h->args);
+    return h->args;
+}
+
+LIBSHIBOKEN_API void PepException_SetArgs(PyObject *ex, PyObject *args)
+{
+    auto *h = reinterpret_cast<PepException_HEAD *>(ex);
+    Py_XINCREF(args);
+    auto *old = h->args; // Py_XSETREF()
+    h->args = args;
+    Py_XDECREF(old);
+
+}
+#endif // Limited or < 3.12
+
 /*****************************************************************************
  *
  * Support for code.h
@@ -448,8 +545,24 @@ PepCode_Get(PepCodeObject *co, const char *name)
     }
     return ret;
 }
+
+int PepCode_Check(PyObject *o)
+{
+    return o != nullptr && std::strcmp(Py_TYPE(o)->tp_name, "code") == 0 ? 1 : 0;
+}
+
 #endif // Py_LIMITED_API
 
+#if defined(Py_LIMITED_API) || defined(PYPY_VERSION)
+PyObject *PepFunction_GetDefaults(PyObject *function)
+{
+    auto *ob_ret = PyObject_GetAttrString(function, "__defaults__");
+    Py_XDECREF(ob_ret); // returns borrowed ref
+    return ob_ret != Py_None ? ob_ret : nullptr;
+}
+
+#endif // defined(Py_LIMITED_API) || defined(PYPY_VERSION)
+
 /*****************************************************************************
  *
  * Support for datetime.h
@@ -650,11 +763,8 @@ PyTypeObject *PepStaticMethod_TypePtr = nullptr;
 static PyTypeObject *
 getStaticMethodType(void)
 {
-    // this works for Python 3, only
-    //    "StaticMethodType = type(str.__dict__['maketrans'])\n";
     static const char prog[] =
-        "from xxsubtype import spamlist\n"
-        "result = type(spamlist.__dict__['staticmeth'])\n";
+        "result = type(str.__dict__['maketrans'])\n";
     return reinterpret_cast<PyTypeObject *>(PepRun_GetResult(prog));
 }
 
@@ -719,12 +829,37 @@ PepType_GetNameStr(PyTypeObject *type)
     return ret;
 }
 
+// PYSIDE-2264: Find the _functools or functools module and retrieve the
+//              partial function. This can be tampered with, check carefully.
+PyObject *
+Pep_GetPartialFunction(void)
+{
+    static bool initialized = false;
+    static PyObject *result{};
+    if (initialized) {
+        Py_INCREF(result);
+        return result;
+    }
+    auto *functools = PyImport_ImportModule("_functools");
+    if (!functools) {
+        PyErr_Clear();
+        functools = PyImport_ImportModule("functools");
+    }
+    if (!functools)
+        Py_FatalError("functools cannot be found");
+    result = PyObject_GetAttrString(functools, "partial");
+    if (!result || !PyCallable_Check(result))
+        Py_FatalError("partial not found or not a function");
+    initialized = true;
+    return result;
+}
+
 /*****************************************************************************
  *
  * Newly introduced convenience functions
  *
  */
-#if PY_VERSION_HEX < 0x03070000 || defined(Py_LIMITED_API)
+#ifdef Py_LIMITED_API
 
 PyObject *
 PyImport_GetModule(PyObject *name)
@@ -750,7 +885,7 @@ PyImport_GetModule(PyObject *name)
     return m;
 }
 
-#endif // PY_VERSION_HEX < 0x03070000 || defined(Py_LIMITED_API)
+#endif // Py_LIMITED_API
 
 // 2020-06-16: For simplicity of creating arbitrary things, this function
 // is now made public.
@@ -841,13 +976,13 @@ _Pep_PrivateMangle(PyObject *self, PyObject *name)
     wchar_t bigbuf[big_stack];
     wchar_t *resbuf = amount <= big_stack ? bigbuf : (wchar_t *)malloc(sizeof(wchar_t) * amount);
     if (!resbuf)
-        return 0;
+        return nullptr;
     /* ident = "_" + priv[ipriv:] + ident # i.e. 1+plen+nlen bytes */
     resbuf[0] = '_';
     if (PyUnicode_AsWideChar(privateobj, resbuf + 1, ipriv + plen) < 0)
-        return 0;
+        return nullptr;
     if (PyUnicode_AsWideChar(name, resbuf + ipriv + plen + 1, nlen) < 0)
-        return 0;
+        return nullptr;
     PyObject *result = PyUnicode_FromWideChar(resbuf + ipriv, 1 + plen + nlen);
     if (amount > big_stack)
         free(resbuf);
@@ -873,6 +1008,21 @@ init_PepRuntime()
         PepRuntime_38_flag = 1;
 }
 
+static long _GetPepRuntimeVersion()
+{
+    auto *version = PySys_GetObject("version_info");
+    const auto major = PyLong_AsLong(PyTuple_GetItem(version, 0));
+    const auto minor = PyLong_AsLong(PyTuple_GetItem(version, 1));
+    const auto micro = PyLong_AsLong(PyTuple_GetItem(version, 2));
+    return major << 16 | minor << 8 | micro;
+}
+
+long _PepRuntimeVersion()
+{
+    static const auto number = _GetPepRuntimeVersion();
+    return number;
+}
+
 /*****************************************************************************
  *
  * PYSIDE-535: Support for PyPy
@@ -882,33 +1032,108 @@ init_PepRuntime()
  *
  */
 
+///////////////////////////////////////////////////////////////////////
+//
+// PEP 697: Support for embedded type structures.
+//
+// According to `https://docs.python.org/3/c-api/object.html?highlight=pyobject_gettypedata#c.PyObject_GetTypeData`
+// the function `PyObject_GetTypeData` should belong to the Stable API
+// since version 3.12.0, but it does not. We use instead some copies
+// from Python source code.
+
+#if !defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030C0000
+
+# define PepObject_GetTypeData PyObject_GetTypeData
+
+SbkObjectTypePrivate *PepType_SOTP(PyTypeObject *type)
+{
+    // PYSIDE-2676: Use the meta type explicitly.
+    //              A derived type would fail the offset calculation.
+    static auto *meta = SbkObjectType_TypeF();
+    assert(SbkObjectType_Check(type));
+    auto *obType = reinterpret_cast<PyObject *>(type);
+    void *data = PyObject_GetTypeData(obType, meta);
+    return reinterpret_cast<SbkObjectTypePrivate *>(data);
+}
+
+void PepType_SOTP_delete(PyTypeObject * /*type*/)
+{
+}
+
+#else
+
+// The following comments are directly copied from Python 3.12
+//
+
+// Make sure we have maximum alignment, even if the current compiler
+// does not support max_align_t. Note that:
+// - Autoconf reports alignment of unknown types to 0.
+// - 'long double' has maximum alignment on *most* platforms,
+//   looks like the best we can do for pre-C11 compilers.
+// - The value is tested, see test_alignof_max_align_t
+#  if !defined(ALIGNOF_MAX_ALIGN_T) || ALIGNOF_MAX_ALIGN_T == 0
+#    undef ALIGNOF_MAX_ALIGN_T
+#    define ALIGNOF_MAX_ALIGN_T alignof(long double)
+#  endif
+
+/* Align up to the nearest multiple of alignof(max_align_t)
+ * (like _Py_ALIGN_UP, but for a size rather than pointer)
+ */
+static Py_ssize_t _align_up(Py_ssize_t size)
+{
+    return (size + ALIGNOF_MAX_ALIGN_T - 1) & ~(ALIGNOF_MAX_ALIGN_T - 1);
+}
+
+static void *PepObject_GetTypeData(PyObject *obj, PyTypeObject *cls)
+{
+    assert(PyObject_TypeCheck(obj, cls));
+    return reinterpret_cast<char *>(obj) + _align_up(cls->tp_base->tp_basicsize);
+}
+//
+///////////////////////////////////////////////////////////////////////
+
 /*
  * PyTypeObject extender
  */
+
 static std::unordered_map<PyTypeObject *, SbkObjectTypePrivate > SOTP_extender{};
 static thread_local PyTypeObject *SOTP_key{};
 static thread_local SbkObjectTypePrivate *SOTP_value{};
 
-SbkObjectTypePrivate *PepType_SOTP(PyTypeObject *sbkType)
+SbkObjectTypePrivate *PepType_SOTP(PyTypeObject *type)
 {
-    if (sbkType == SOTP_key)
+    static auto *meta = SbkObjectType_TypeF();
+    static bool use_312 = _PepRuntimeVersion() >= 0x030C00;
+    assert(SbkObjectType_Check(type));
+    if (use_312) {
+        auto *obType = reinterpret_cast<PyObject *>(type);
+        void *data = PepObject_GetTypeData(obType, meta);
+        return reinterpret_cast<SbkObjectTypePrivate *>(data);
+    }
+    if (type == SOTP_key)
         return SOTP_value;
-    auto it = SOTP_extender.find(sbkType);
+    auto it = SOTP_extender.find(type);
     if (it == SOTP_extender.end()) {
-        it = SOTP_extender.insert({sbkType, {}}).first;
+        it = SOTP_extender.insert({type, {}}).first;
         memset(&it->second, 0, sizeof(SbkObjectTypePrivate));
     }
-    SOTP_key = sbkType;
+    SOTP_key = type;
     SOTP_value = &it->second;
     return SOTP_value;
 }
 
-void PepType_SOTP_delete(PyTypeObject *sbkType)
+void PepType_SOTP_delete(PyTypeObject *type)
 {
-    SOTP_extender.erase(sbkType);
+    static bool use_312 = _PepRuntimeVersion() >= 0x030C00;
+    assert(SbkObjectType_Check(type));
+    if (use_312)
+        return;
+    SOTP_extender.erase(type);
     SOTP_key = nullptr;
 }
 
+#endif // !defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030C0000
+
 /*
  * SbkEnumType extender
  */
@@ -918,6 +1143,7 @@ static thread_local SbkEnumTypePrivate *SETP_value{};
 
 SbkEnumTypePrivate *PepType_SETP(SbkEnumType *enumType)
 {
+    // PYSIDE-2230: This makes no sense at all for Enum types.
     if (enumType == SETP_key)
         return SETP_value;
     auto it = SETP_extender.find(enumType);
@@ -936,38 +1162,76 @@ void PepType_SETP_delete(SbkEnumType *enumType)
     SETP_key = nullptr;
 }
 
-/*
- * PySideQFlagsType extender
- */
-static std::unordered_map<PySideQFlagsType *, PySideQFlagsTypePrivate> PFTP_extender{};
-static thread_local PySideQFlagsType *PFTP_key{};
-static thread_local PySideQFlagsTypePrivate *PFTP_value{};
-
-PySideQFlagsTypePrivate *PepType_PFTP(PySideQFlagsType *flagsType)
-{
-    static PyTypeObject *enumMeta = getPyEnumMeta();
-    auto *mappedType = reinterpret_cast<PyTypeObject *>(flagsType);
-    auto *metaType = Py_TYPE(mappedType);
-    if (metaType == enumMeta) {
-        return reinterpret_cast<PySideQFlagsTypePrivate *>(
-            PepType_SETP(reinterpret_cast<SbkEnumType *>(flagsType)));
-    }
-    if (flagsType == PFTP_key)
-        return PFTP_value;
-    auto it = PFTP_extender.find(flagsType);
-    if (it == PFTP_extender.end()) {
-        it = PFTP_extender.insert({flagsType, {}}).first;
-        memset(&it->second, 0, sizeof(PySideQFlagsTypePrivate));
+#ifdef Py_LIMITED_API
+static PyObject *emulatePyType_GetDict(PyTypeObject *type)
+{
+    if (_PepRuntimeVersion() < 0x030C00 || type->tp_dict) {
+        auto *res = type->tp_dict;
+        Py_XINCREF(res);
+        return res;
     }
-    PFTP_key = flagsType;
-    PFTP_value = &it->second;
-    return PFTP_value;
+    // PYSIDE-2230: Here we are really cheating. We don't know how to
+    //              access an internal dict, and so we simply pretend
+    //              it were an empty dict. This works great for our types.
+    // This was an unexpectedly simple solution :D
+    return PyDict_New();
 }
+#endif
 
-void PepType_PFTP_delete(PySideQFlagsType *flagsType)
+// PyType_GetDict: replacement for <static type>.tp_dict, which is
+// zero for builtin types since 3.12.
+PyObject *PepType_GetDict(PyTypeObject *type)
 {
-    PFTP_extender.erase(flagsType);
-    PFTP_key = nullptr;
+#if !defined(Py_LIMITED_API)
+#  if PY_VERSION_HEX >= 0x030C0000
+    return PyType_GetDict(type);
+#  else
+    // pre 3.12 fallback code, mimicking the addref-behavior.
+    Py_XINCREF(type->tp_dict);
+    return type->tp_dict;
+#  endif
+#else
+    return emulatePyType_GetDict(type);
+#endif // Py_LIMITED_API
+}
+
+int PepType_SetDict(PyTypeObject *type, PyObject *dict)
+{
+    type->tp_dict = dict;
+    return 0;
+}
+
+// Pre 3.10, PyType_GetSlot() would only work for heap types.
+// FIXME: PyType_GetSlot() can be used unconditionally when the
+// minimum limited API version is >= 3.10.
+void *PepType_GetSlot(PyTypeObject *type, int aSlot)
+{
+    static const bool is310 = _PepRuntimeVersion() >= 0x030A00;
+    if (is310 || (type->tp_flags & Py_TPFLAGS_HEAPTYPE) != 0)
+        return PyType_GetSlot(type, aSlot);
+
+    switch (aSlot) {
+    case Py_tp_alloc:
+        return reinterpret_cast<void *>(type->tp_alloc);
+    case Py_tp_getattro:
+        return reinterpret_cast<void *>(type->tp_getattro);
+    case Py_tp_setattro:
+        return reinterpret_cast<void *>(type->tp_setattro);
+    case Py_tp_descr_get:
+        return reinterpret_cast<void *>(type->tp_descr_get);
+    case Py_tp_descr_set:
+        return reinterpret_cast<void *>(type->tp_descr_set);
+    case Py_tp_call:
+        return reinterpret_cast<void *>(type->tp_call);
+    case Py_tp_new:
+        return reinterpret_cast<void *>(type->tp_new);
+    case Py_tp_init:
+        return reinterpret_cast<void *>(type->tp_init);
+    case Py_tp_free:
+        return reinterpret_cast<void *>(type->tp_free);
+    }
+    assert(false);
+    return nullptr;
 }
 
 /***************************************************************************
@@ -1001,16 +1265,16 @@ static inline void *PepType_ExTP(PyTypeObject *type, size_t size)
         static PyTypeObject *alias{};
         const char *kind = size == sizeof(SbkObjectTypePrivate) ? "SOTP" :
                            size == sizeof(SbkEnumTypePrivate) ? "SETP" :
-                           size == sizeof(PySideQFlagsTypePrivate) ? "PFTP" :
+                           size == sizeof(SbkQFlagsTypePrivate) ? "PFTP" :
                            "unk.";
         fprintf(stderr, "%s:%d %p x %s s=%ld\n", __func__, __LINE__, type, kind, size);
         PyObject *kill{};
         if (strlen(env_p) > 0) {
-            if (size == sizeof(PySideQFlagsTypePrivate)) {
+            if (size == sizeof(SbkQFlagsTypePrivate)) {
                 if (alias == nullptr)
                     alias = type;
             }
-            if (size != sizeof(PySideQFlagsTypePrivate)) {
+            if (size != sizeof(SbkQFlagsTypePrivate)) {
                 if (type == alias)
                     Py_INCREF(kill);
             }
diff --git a/sources/shiboken6/libshiboken/pep384impl.h b/sources/shiboken6/libshiboken/pep384impl.h
index 07cdb3a6f..7188366e2 100644
--- a/sources/shiboken6/libshiboken/pep384impl.h
+++ b/sources/shiboken6/libshiboken/pep384impl.h
@@ -4,11 +4,6 @@
 #ifndef PEP384IMPL_H
 #define PEP384IMPL_H
 
-// PYSIDE-1436: Adapt to Python 3.10
-#if PY_VERSION_HEX < 0x030900A4
-#  define Py_SET_REFCNT(obj, refcnt) ((Py_REFCNT(obj) = (refcnt)), (void)0)
-#endif
-
 extern "C"
 {
 
@@ -55,42 +50,79 @@ typedef struct _typeobject {
     const char *tp_name;
     Py_ssize_t tp_basicsize;
     void *X03; // Py_ssize_t tp_itemsize;
+#ifdef PEP384_INTERN
     destructor tp_dealloc;
+#else
+    destructor X04;
+#endif
     void *X05; // Py_ssize_t tp_vectorcall_offset;
     void *X06; // getattrfunc tp_getattr;
     void *X07; // setattrfunc tp_setattr;
     void *X08; // PyAsyncMethods *tp_as_async;
+#ifdef PEP384_INTERN
     reprfunc tp_repr;
+#else
+    reprfunc X09;
+#endif
     void *X10; // PyNumberMethods *tp_as_number;
     void *X11; // PySequenceMethods *tp_as_sequence;
     void *X12; // PyMappingMethods *tp_as_mapping;
     void *X13; // hashfunc tp_hash;
+#ifdef PEP384_INTERN
     ternaryfunc tp_call;
-    reprfunc tp_str;
+#else
+    ternaryfunc X14;
+#endif
+    reprfunc tp_str; // Only used for PEP384_INTERN and a shiboken test
     getattrofunc tp_getattro;
     setattrofunc tp_setattro;
     void *X18; // PyBufferProcs *tp_as_buffer;
     unsigned long tp_flags;
     void *X20; // const char *tp_doc;
+#ifdef PEP384_INTERN
     traverseproc tp_traverse;
     inquiry tp_clear;
+#else
+    traverseproc X21;
+    inquiry X22;
+#endif
     void *X23; // richcmpfunc tp_richcompare;
     Py_ssize_t tp_weaklistoffset;
     void *X25; // getiterfunc tp_iter;
+#ifdef PEP384_INTERN
     iternextfunc tp_iternext;
+#else
+    iternextfunc X26;
+#endif
     struct PyMethodDef *tp_methods;
     struct PyMemberDef *tp_members;
     struct PyGetSetDef *tp_getset;
     struct _typeobject *tp_base;
+#ifdef PEP384_INTERN
     PyObject *tp_dict;
     descrgetfunc tp_descr_get;
     descrsetfunc tp_descr_set;
+#else
+    void *X31;
+    descrgetfunc X32;
+    descrsetfunc X33;
+#endif
     Py_ssize_t tp_dictoffset;
+#ifdef PEP384_INTERN
     initproc tp_init;
     allocfunc tp_alloc;
+#else
+    initproc X39;
+    allocfunc X40;
+#endif
     newfunc tp_new;
+#ifdef PEP384_INTERN
     freefunc tp_free;
     inquiry tp_is_gc; /* For PyObject_IS_GC */
+#else
+    freefunc X41;
+    inquiry X42; /* For PyObject_IS_GC */
+#endif
     PyObject *tp_bases;
     PyObject *tp_mro; /* method resolution order */
 
@@ -103,24 +135,16 @@ typedef struct _typeobject {
      && (Py_TYPE(o)->tp_is_gc == NULL || Py_TYPE(o)->tp_is_gc(o)))
 #endif
 
-// This was a macro error in the limited API from the beginning.
-// It was fixed in Python master, but did make it only into Python 3.8 .
-
-// PYSIDE-1797: This must be a runtime decision.
-//              Remove that when the minimum Python version is 3.8,
-//              because the macro PepIndex_Check bug was fixed then.
-/// FIXME: Remove PepIndex_Check and pep384_issue33738.cpp when Python 3.7 is gone.
-LIBSHIBOKEN_API int PepIndex_Check(PyObject *obj);
-
 LIBSHIBOKEN_API PyObject *_PepType_Lookup(PyTypeObject *type, PyObject *name);
 
 #else // Py_LIMITED_API
 
-#define PepIndex_Check(obj)               PyIndex_Check(obj)
 #define _PepType_Lookup(type, name)       _PyType_Lookup(type, name)
 
 #endif // Py_LIMITED_API
 
+/// PYSIDE-939: We need the runtime version, given major << 16 + minor << 8 + micro
+LIBSHIBOKEN_API long _PepRuntimeVersion();
 /*****************************************************************************
  *
  * PYSIDE-535: Implement a clean type extension for PyPy
@@ -139,16 +163,15 @@ LIBSHIBOKEN_API SbkEnumTypePrivate *PepType_SETP(SbkEnumType *type);
 LIBSHIBOKEN_API void PepType_SETP_delete(SbkEnumType *enumType);
 
 struct PySideQFlagsType;
-struct PySideQFlagsTypePrivate;
-
-LIBSHIBOKEN_API PySideQFlagsTypePrivate *PepType_PFTP(PySideQFlagsType *type);
-LIBSHIBOKEN_API void PepType_PFTP_delete(PySideQFlagsType *flagsType);
+struct SbkQFlagsTypePrivate;
 
 /*****************************************************************************/
 
 // functions used everywhere
 LIBSHIBOKEN_API const char *PepType_GetNameStr(PyTypeObject *type);
 
+LIBSHIBOKEN_API PyObject *Pep_GetPartialFunction(void);
+
 /*****************************************************************************
  *
  * RESOLVED: pydebug.h
@@ -163,7 +186,17 @@ LIBSHIBOKEN_API const char *PepType_GetNameStr(PyTypeObject *type);
  */
 LIBSHIBOKEN_API int Pep_GetFlag(const char *name);
 LIBSHIBOKEN_API int Pep_GetVerboseFlag(void);
-#define Py_VerboseFlag              Pep_GetVerboseFlag()
+#endif
+
+// pyerrors.h
+#if defined(Py_LIMITED_API) || PY_VERSION_HEX < 0x030C0000
+LIBSHIBOKEN_API PyObject *PepErr_GetRaisedException();
+LIBSHIBOKEN_API PyObject *PepException_GetArgs(PyObject *ex);
+LIBSHIBOKEN_API void PepException_SetArgs(PyObject *ex, PyObject *args);
+#else
+#  define PepErr_GetRaisedException PyErr_GetRaisedException
+#  define PepException_GetArgs PyException_GetArgs
+#  define PepException_SetArgs PyException_SetArgs
 #endif
 
 /*****************************************************************************
@@ -201,7 +234,9 @@ LIBSHIBOKEN_API int Pep_GetVerboseFlag(void);
 LIBSHIBOKEN_API const char *_PepUnicode_AsString(PyObject *);
 
 enum PepUnicode_Kind {
+#if PY_VERSION_HEX < 0x030C0000
     PepUnicode_WCHAR_KIND = 0,
+#endif
     PepUnicode_1BYTE_KIND = 1,
     PepUnicode_2BYTE_KIND = 2,
     PepUnicode_4BYTE_KIND = 4
@@ -216,7 +251,9 @@ LIBSHIBOKEN_API void *_PepUnicode_DATA(PyObject *str);
 #else
 
 enum PepUnicode_Kind {
+#if PY_VERSION_HEX < 0x030C0000
     PepUnicode_WCHAR_KIND = PyUnicode_WCHAR_KIND,
+#endif
     PepUnicode_1BYTE_KIND = PyUnicode_1BYTE_KIND,
     PepUnicode_2BYTE_KIND = PyUnicode_2BYTE_KIND,
     PepUnicode_4BYTE_KIND =  PyUnicode_4BYTE_KIND
@@ -278,7 +315,7 @@ enum PepUnicode_Kind {
 
 #ifdef Py_LIMITED_API
 
-typedef struct _pycfunc PyCFunctionObject;
+using PyCFunctionObject = struct _pycfunc;
 #define PyCFunction_GET_FUNCTION(func)  PyCFunction_GetFunction((PyObject *)func)
 #define PyCFunction_GET_SELF(func)      PyCFunction_GetSelf((PyObject *)func)
 #define PyCFunction_GET_FLAGS(func)     PyCFunction_GetFlags((PyObject *)func)
@@ -393,10 +430,13 @@ LIBSHIBOKEN_API PyObject *PyMethod_Self(PyObject *);
 typedef struct _code PepCodeObject;
 
 LIBSHIBOKEN_API int PepCode_Get(PepCodeObject *co, const char *name);
+LIBSHIBOKEN_API int PepCode_Check(PyObject *o);
 
 #  define PepCode_GET_FLAGS(o)         PepCode_Get(o, "co_flags")
 #  define PepCode_GET_ARGCOUNT(o)      PepCode_Get(o, "co_argcount")
 
+LIBSHIBOKEN_API PyObject *PepFunction_GetDefaults(PyObject *function);
+
 /* Masks for co_flags above */
 #  define CO_OPTIMIZED    0x0001
 #  define CO_NEWLOCALS    0x0002
@@ -410,7 +450,15 @@ LIBSHIBOKEN_API int PepCode_Get(PepCodeObject *co, const char *name);
 #  define PepCodeObject                PyCodeObject
 #  define PepCode_GET_FLAGS(o)         ((o)->co_flags)
 #  define PepCode_GET_ARGCOUNT(o)      ((o)->co_argcount)
+#  define PepCode_Check PyCode_Check
+
+#  ifdef PYPY_VERSION
+
+LIBSHIBOKEN_API PyObject *PepFunction_GetDefaults(PyObject *function);
 
+#    else
+#    define PepFunction_GetDefaults PyFunction_GetDefaults
+#  endif
 #endif
 
 /*****************************************************************************
@@ -511,9 +559,9 @@ extern LIBSHIBOKEN_API PyTypeObject *PepBuiltinMethod_TypePtr;
  *
  * This is not defined if Py_LIMITED_API is defined.
  */
-#if PY_VERSION_HEX < 0x03070000 || defined(Py_LIMITED_API)
+#ifdef Py_LIMITED_API
 LIBSHIBOKEN_API PyObject *PyImport_GetModule(PyObject *name);
-#endif // PY_VERSION_HEX < 0x03070000 || defined(Py_LIMITED_API)
+#endif // Py_LIMITED_API
 
 // Evaluate a script and return the variable `result`
 LIBSHIBOKEN_API PyObject *PepRun_GetResult(const char *command);
@@ -538,6 +586,20 @@ extern LIBSHIBOKEN_API int PepRuntime_38_flag;
 
 /*****************************************************************************
  *
+ * Runtime support for Python 3.12 incompatibility
+ *
+ */
+
+LIBSHIBOKEN_API PyObject *PepType_GetDict(PyTypeObject *type);
+
+// This function does not exist as PyType_SetDict. But because tp_dict
+// is no longer considered to be accessible, we treat it as such.
+LIBSHIBOKEN_API int PepType_SetDict(PyTypeObject *type, PyObject *dict);
+
+LIBSHIBOKEN_API void *PepType_GetSlot(PyTypeObject *type, int aSlot);
+
+/*****************************************************************************
+ *
  * Module Initialization
  *
  */
diff --git a/sources/shiboken6/libshiboken/pyobjectholder.h b/sources/shiboken6/libshiboken/pyobjectholder.h
new file mode 100644
index 000000000..857748c2f
--- /dev/null
+++ b/sources/shiboken6/libshiboken/pyobjectholder.h
@@ -0,0 +1,86 @@
+// 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 PYOBJECTHOLDER_H
+#define PYOBJECTHOLDER_H
+
+#include "sbkpython.h"
+
+#include <cassert>
+#include <utility>
+
+namespace Shiboken
+{
+
+/// PyObjectHolder holds a PyObject pointer, keeping a reference decrementing
+/// its reference counter when destroyed. It makes sure to hold the GIL when
+/// releasing. It implements copy/move semantics and is mainly intended as a
+/// base class for functors holding a callable which can be passed around and
+/// stored in containers or moved from freely.
+/// For one-shot functors, release() can be invoked after the call.
+class PyObjectHolder
+{
+public:
+    PyObjectHolder() noexcept = default;
+
+    /// PyObjectHolder constructor.
+    /// \param pyobj A reference to a Python object
+    explicit PyObjectHolder(PyObject *pyObj) noexcept : m_pyObj(pyObj)
+    {
+        assert(pyObj != nullptr);
+        Py_INCREF(m_pyObj);
+    }
+
+    PyObjectHolder(const PyObjectHolder &o) noexcept : m_pyObj(o.m_pyObj)
+    {
+        Py_XINCREF(m_pyObj);
+    }
+
+    PyObjectHolder &operator=(const PyObjectHolder &o) noexcept
+    {
+        if (this != &o) {
+            m_pyObj = o.m_pyObj;
+            Py_XINCREF(m_pyObj);
+        }
+        return *this;
+    }
+
+    PyObjectHolder(PyObjectHolder &&o) noexcept : m_pyObj{std::exchange(o.m_pyObj, nullptr)} {}
+
+    PyObjectHolder &operator=(PyObjectHolder &&o) noexcept
+    {
+        m_pyObj = std::exchange(o.m_pyObj, nullptr);
+        return *this;
+    }
+
+    /// Decref the python reference
+    ~PyObjectHolder() { release(); }
+
+    [[nodiscard]] bool isNull() const { return m_pyObj == nullptr; }
+    [[nodiscard]] operator bool() const { return m_pyObj != nullptr; }
+
+    /// Returns the pointer of the Python object being held.
+    [[nodiscard]] PyObject *object() const { return m_pyObj; }
+    [[nodiscard]] operator PyObject *() const { return m_pyObj; }
+
+    [[nodiscard]] PyObject *operator->() { return m_pyObj; }
+
+protected:
+    void release()
+    {
+        if (m_pyObj != nullptr) {
+            assert(Py_IsInitialized());
+            auto gstate = PyGILState_Ensure();
+            Py_DECREF(m_pyObj);
+            PyGILState_Release(gstate);
+            m_pyObj = nullptr;
+        }
+    }
+
+private:
+    PyObject *m_pyObj = nullptr;
+};
+
+} // namespace Shiboken
+
+#endif // PYOBJECTHOLDER_H
diff --git a/sources/shiboken6/libshiboken/sbkarrayconverter.cpp b/sources/shiboken6/libshiboken/sbkarrayconverter.cpp
index 8af310a53..bcc3fb767 100644
--- a/sources/shiboken6/libshiboken/sbkarrayconverter.cpp
+++ b/sources/shiboken6/libshiboken/sbkarrayconverter.cpp
@@ -14,8 +14,7 @@
 
 static SbkArrayConverter *ArrayTypeConverters[Shiboken::Conversions::SBK_ARRAY_IDX_SIZE] [2] = {};
 
-namespace Shiboken {
-namespace Conversions {
+namespace Shiboken::Conversions {
 
 // Check whether Predicate is true for all elements of a sequence
 template <class Predicate>
@@ -244,5 +243,4 @@ void setArrayTypeConverter(int index, int dimension, SbkArrayConverter *c)
     ArrayTypeConverters[index][dimension - 1] = c;
 }
 
-} // namespace Conversions
-} // namespace Shiboken
+} // namespace Shiboken::Conversions
diff --git a/sources/shiboken6/libshiboken/sbkarrayconverter.h b/sources/shiboken6/libshiboken/sbkarrayconverter.h
index 97bd8ac6f..f07cb1d70 100644
--- a/sources/shiboken6/libshiboken/sbkarrayconverter.h
+++ b/sources/shiboken6/libshiboken/sbkarrayconverter.h
@@ -11,8 +11,7 @@ extern "C" {
 struct SbkArrayConverter;
 }
 
-namespace Shiboken {
-namespace Conversions {
+namespace Shiboken::Conversions {
 
 enum : int {
     SBK_UNIMPLEMENTED_ARRAY_IDX,
@@ -132,7 +131,6 @@ void ArrayHandle<T>::destroy()
     m_owned = false;
 }
 
-} // namespace Conversions
-} // namespace Shiboken
+} // namespace Shiboken::Conversions
 
 #endif // SBKARRAYCONVERTERS_H
diff --git a/sources/shiboken6/libshiboken/sbkarrayconverter_p.h b/sources/shiboken6/libshiboken/sbkarrayconverter_p.h
index db92e56af..63d03fb12 100644
--- a/sources/shiboken6/libshiboken/sbkarrayconverter_p.h
+++ b/sources/shiboken6/libshiboken/sbkarrayconverter_p.h
@@ -10,7 +10,7 @@
 extern "C"
 {
 
-typedef PythonToCppFunc (*IsArrayConvertibleToCppFunc)(PyObject *, int dim1, int dim2);
+using IsArrayConvertibleToCppFunc = PythonToCppFunc (*)(PyObject *, int dim1, int dim2);
 /**
  *  \internal
  *  Private structure of SbkArrayConverter.
diff --git a/sources/shiboken6/libshiboken/sbkcontainer.cpp b/sources/shiboken6/libshiboken/sbkcontainer.cpp
index 13c9f1a29..7de1f03e6 100644
--- a/sources/shiboken6/libshiboken/sbkcontainer.cpp
+++ b/sources/shiboken6/libshiboken/sbkcontainer.cpp
@@ -3,14 +3,17 @@
 
 #include "sbkcontainer.h"
 #include "sbkstaticstrings.h"
+#include "autodecref.h"
 
 namespace Shiboken
 {
 bool isOpaqueContainer(PyObject *o)
 {
+    if (!o)
+        return false;
+    Shiboken::AutoDecRef tpDict(PepType_GetDict(o->ob_type));
     return o != nullptr && o != Py_None
-        && PyDict_Contains(o->ob_type->tp_dict,
-                           Shiboken::PyMagicName::opaque_container()) == 1;
+        && PyDict_Contains(tpDict.object(), Shiboken::PyMagicName::opaque_container()) == 1;
 
 }
 } // Shiboken
diff --git a/sources/shiboken6/libshiboken/sbkcontainer.h b/sources/shiboken6/libshiboken/sbkcontainer.h
index 22513d3a0..8ad5aadc6 100644
--- a/sources/shiboken6/libshiboken/sbkcontainer.h
+++ b/sources/shiboken6/libshiboken/sbkcontainer.h
@@ -63,7 +63,8 @@ public:
 
     static PyObject *tpNew(PyTypeObject *subtype, PyObject * /* args */, PyObject * /* kwds */)
     {
-        auto *me = reinterpret_cast<ShibokenContainer *>(subtype->tp_alloc(subtype, 0));
+        allocfunc allocFunc = reinterpret_cast<allocfunc>(PepType_GetSlot(subtype, Py_tp_alloc));
+        auto *me = reinterpret_cast<ShibokenContainer *>(allocFunc(subtype, 0));
         auto *d = new ShibokenSequenceContainerPrivate;
         d->m_list = new SequenceContainer;
         d->m_ownsList = true;
@@ -71,6 +72,13 @@ public:
         return reinterpret_cast<PyObject *>(me);
     }
 
+    static PyObject *tpNewInvalid(PyTypeObject * /* subtype */, PyObject * /* args */, PyObject * /* kwds */)
+    {
+        return PyErr_Format(PyExc_NotImplementedError,
+                     "Opaque containers of type '%s' cannot be instantiated.",
+                     typeid(SequenceContainer).name());
+    }
+
     static int tpInit(PyObject * /* self */, PyObject * /* args */, PyObject * /* kwds */)
     {
         return 0;
@@ -83,7 +91,9 @@ public:
         if (d->m_ownsList)
             delete d->m_list;
         delete d;
-        Py_TYPE(pySelf)->tp_base->tp_free(self);
+        auto freeFunc = reinterpret_cast<freefunc>(PepType_GetSlot(Py_TYPE(pySelf)->tp_base,
+                                                                   Py_tp_free));
+        freeFunc(self);
     }
 
     static Py_ssize_t sqLen(PyObject *self)
@@ -94,11 +104,9 @@ public:
     static PyObject *sqGetItem(PyObject *self, Py_ssize_t i)
     {
         auto *d = get(self);
-        if (i < 0 || i >= Py_ssize_t(d->m_list->size())) {
-            PyErr_SetString(PyExc_IndexError, "index out of bounds");
-            return nullptr;
-        }
-        auto it = d->m_list->cbegin();
+        if (i < 0 || i >= Py_ssize_t(d->m_list->size()))
+            return PyErr_Format(PyExc_IndexError, "index out of bounds");
+        auto it = std::cbegin(*d->m_list);
         std::advance(it, i);
         return ShibokenContainerValueConverter<value_type>::convertValueToPython(*it);
     }
@@ -110,7 +118,7 @@ public:
             PyErr_SetString(PyExc_IndexError, "index out of bounds");
             return -1;
         }
-        auto it = d->m_list->begin();
+        auto it = std::begin(*d->m_list);
         std::advance(it, i);
         OptionalValue value = ShibokenContainerValueConverter<value_type>::convertValueToCpp(pyArg);
         if (!value.has_value())
@@ -122,14 +130,10 @@ public:
     static PyObject *push_back(PyObject *self, PyObject *pyArg)
     {
         auto *d = get(self);
-        if (!ShibokenContainerValueConverter<value_type>::checkValue(pyArg)) {
-            PyErr_SetString(PyExc_TypeError, "wrong type passed to append.");
-            return nullptr;
-        }
-        if (d->m_const) {
-            PyErr_SetString(PyExc_TypeError, msgModifyConstContainer);
-            return nullptr;
-        }
+        if (!ShibokenContainerValueConverter<value_type>::checkValue(pyArg))
+            return PyErr_Format(PyExc_TypeError, "wrong type passed to append.");
+        if (d->m_const)
+            return PyErr_Format(PyExc_TypeError, msgModifyConstContainer);
 
         OptionalValue value = ShibokenContainerValueConverter<value_type>::convertValueToCpp(pyArg);
         if (!value.has_value())
@@ -141,14 +145,10 @@ public:
     static PyObject *push_front(PyObject *self, PyObject *pyArg)
     {
         auto *d = get(self);
-        if (!ShibokenContainerValueConverter<value_type>::checkValue(pyArg)) {
-            PyErr_SetString(PyExc_TypeError, "wrong type passed to append.");
-            return nullptr;
-        }
-        if (d->m_const) {
-            PyErr_SetString(PyExc_TypeError, msgModifyConstContainer);
-            return nullptr;
-        }
+        if (!ShibokenContainerValueConverter<value_type>::checkValue(pyArg))
+            return PyErr_Format(PyExc_TypeError, "wrong type passed to append.");
+        if (d->m_const)
+            return PyErr_Format(PyExc_TypeError, msgModifyConstContainer);
 
         OptionalValue value = ShibokenContainerValueConverter<value_type>::convertValueToCpp(pyArg);
         if (!value.has_value())
@@ -160,10 +160,8 @@ public:
     static PyObject *clear(PyObject *self)
     {
         auto *d = get(self);
-        if (d->m_const) {
-            PyErr_SetString(PyExc_TypeError, msgModifyConstContainer);
-            return nullptr;
-        }
+        if (d->m_const)
+            return PyErr_Format(PyExc_TypeError, msgModifyConstContainer);
 
         d->m_list->clear();
         Py_RETURN_NONE;
@@ -172,10 +170,8 @@ public:
     static PyObject *pop_back(PyObject *self)
     {
         auto *d = get(self);
-        if (d->m_const) {
-            PyErr_SetString(PyExc_TypeError, msgModifyConstContainer);
-            return nullptr;
-        }
+        if (d->m_const)
+            return PyErr_Format(PyExc_TypeError, msgModifyConstContainer);
 
         d->m_list->pop_back();
         Py_RETURN_NONE;
@@ -184,10 +180,8 @@ public:
     static PyObject *pop_front(PyObject *self)
     {
         auto *d = get(self);
-        if (d->m_const) {
-            PyErr_SetString(PyExc_TypeError, msgModifyConstContainer);
-            return nullptr;
-        }
+        if (d->m_const)
+            return PyErr_Format(PyExc_TypeError, msgModifyConstContainer);
 
         d->m_list->pop_front();
         Py_RETURN_NONE;
@@ -197,21 +191,16 @@ public:
     static PyObject *reserve(PyObject *self, PyObject *pyArg)
     {
         auto *d = get(self);
-        if (PyLong_Check(pyArg) == 0) {
-            PyErr_SetString(PyExc_TypeError, "wrong type passed to reserve().");
-            return nullptr;
-        }
-        if (d->m_const) {
-            PyErr_SetString(PyExc_TypeError, msgModifyConstContainer);
-            return nullptr;
-        }
+        if (PyLong_Check(pyArg) == 0)
+            return PyErr_Format(PyExc_TypeError, "wrong type passed to reserve().");
+        if (d->m_const)
+            return PyErr_Format(PyExc_TypeError, msgModifyConstContainer);
 
         if constexpr (ShibokenContainerHasReserve<SequenceContainer>::value) {
             const Py_ssize_t size = PyLong_AsSsize_t(pyArg);
             d->m_list->reserve(size);
         } else {
-            PyErr_SetString(PyExc_TypeError, "Container does not support reserve().");
-            return nullptr;
+            return PyErr_Format(PyExc_TypeError, "Container does not support reserve().");
         }
 
         Py_RETURN_NONE;
diff --git a/sources/shiboken6/libshiboken/sbkconverter.cpp b/sources/shiboken6/libshiboken/sbkconverter.cpp
index 309810290..9ab674415 100644
--- a/sources/shiboken6/libshiboken/sbkconverter.cpp
+++ b/sources/shiboken6/libshiboken/sbkconverter.cpp
@@ -4,6 +4,7 @@
 #include "sbkconverter.h"
 #include "sbkconverter_p.h"
 #include "sbkarrayconverter_p.h"
+#include "sbkmodule.h"
 #include "basewrapper_p.h"
 #include "bindingmanager.h"
 #include "autodecref.h"
@@ -11,15 +12,19 @@
 #include "voidptr.h"
 
 #include <string>
+#include <cstring>
+#include <iostream>
 #include <unordered_map>
+#include <unordered_set>
+#include <map>
+#include <set>
 
 static SbkConverter **PrimitiveTypeConverters;
 
 using ConvertersMap = std::unordered_map<std::string, SbkConverter *>;
 static ConvertersMap converters;
 
-namespace Shiboken {
-namespace Conversions {
+namespace Shiboken::Conversions {
 
 void initArrayConverters();
 
@@ -72,6 +77,103 @@ void init()
     initArrayConverters();
 }
 
+static void dumpPyTypeObject(std::ostream &str, PyTypeObject *t)
+{
+    str << "\nPython type ";
+    if (t == nullptr) {
+        str << "<None>";
+        return;
+    }
+    str << '"' << t->tp_name << '"';
+    if (t->tp_base != nullptr && t->tp_base != &PyBaseObject_Type)
+        str << '(' << t->tp_base->tp_name << ')';
+}
+
+static void dumpSbkConverter(std::ostream &str, const SbkConverter *c)
+{
+    str << "SbkConverter " << static_cast<const void *>(c) << ": ";
+    if (c->pointerToPython != nullptr)
+        str << ", C++ pointer->Python";
+    if (c->copyToPython != nullptr)
+        str << ", copy->Python";
+    if (c->toCppPointerConversion.second != nullptr)
+        str << ", Python->C++ pointer";
+    if (!c->toCppConversions.empty())
+        str << ", " << c->toCppConversions.size() << " Python->C++ conversions";
+}
+
+// Less than operator for a PyTypeObject for dumping the converter map
+static bool pyTypeObjectLessThan(const PyTypeObject *t1, const PyTypeObject *t2)
+{
+    const bool isNull1 = t1 == nullptr;
+    const bool isNull2 = t2 == nullptr;
+    if (isNull1 || isNull2)
+        return isNull1 && !isNull2;
+    // Internal types (lower case) first
+    const bool isInternal1 = std::islower(t1->tp_name[0]);
+    const bool isInternal2 = std::islower(t2->tp_name[0]);
+    if (isInternal1 != isInternal2)
+        return !isInternal2;
+    return std::strcmp(t1->tp_name, t2->tp_name) < 0;
+}
+
+void dumpConverters()
+{
+    struct PyTypeObjectLess {
+
+        bool operator()(const PyTypeObject *t1, const PyTypeObject *t2) const {
+            return pyTypeObjectLessThan(t1, t2);
+        }
+    };
+
+    using StringSet = std::set<std::string>;
+    using SbkConverterNamesMap = std::unordered_map<SbkConverter *, StringSet>;
+    using PyTypeObjectConverterMap = std::map<PyTypeObject *, SbkConverterNamesMap,
+                                              PyTypeObjectLess>;
+
+    auto &str = std::cerr;
+
+    // Sort the entries by the associated PyTypeObjects and converters
+    PyTypeObjectConverterMap pyTypeObjectConverterMap;
+    for (const auto &converter : converters) {
+        auto *sbkConverter = converter.second;
+        if (sbkConverter == nullptr) {
+            str << "Non-existent: \"" << converter.first << "\"\n";
+            continue;
+        }
+        auto *typeObject = sbkConverter->pythonType;
+        auto typeIt = pyTypeObjectConverterMap.find(typeObject);
+        if (typeIt == pyTypeObjectConverterMap.end())
+            typeIt = pyTypeObjectConverterMap.insert(std::make_pair(typeObject,
+                                                                    SbkConverterNamesMap{})).first;
+        SbkConverterNamesMap &sbkConverterMap = typeIt->second;
+        auto convIt = sbkConverterMap.find(sbkConverter);
+        if (convIt == sbkConverterMap.end())
+            convIt = sbkConverterMap.insert(std::make_pair(sbkConverter,
+                                                           StringSet{})).first;
+        convIt->second.insert(converter.first);
+    }
+
+     for (const auto &tc : pyTypeObjectConverterMap) {
+         dumpPyTypeObject(str, tc.first);
+         str << ", " << tc.second.size() << " converter(s):\n";
+         for (const auto &cn : tc.second) {
+             str << "    ";
+             dumpSbkConverter(str, cn.first);
+             str << ", " << cn.second.size() << " alias(es):";
+             int i = 0;
+             for (const auto &name : cn.second) {
+                 if ((i++ % 5) == 0)
+                     str << "\n        ";
+                 str << " \"" << name << '"';
+             }
+             str << '\n';
+         }
+    }
+
+    str << '\n';
+}
+
 SbkConverter *createConverterObject(PyTypeObject *type,
                                            PythonToCppFunc toCppPointerConvFunc,
                                            IsConvertibleToCppFunc toCppPointerCheckFunc,
@@ -147,6 +249,13 @@ void addPythonToCppValueConversion(PyTypeObject *type,
     addPythonToCppValueConversion(sotp->converter, pythonToCppFunc, isConvertibleToCppFunc);
 }
 
+void addPythonToCppValueConversion(Shiboken::Module::TypeInitStruct typeStruct,
+                                   PythonToCppFunc pythonToCppFunc,
+                                   IsConvertibleToCppFunc isConvertibleToCppFunc)
+{
+    addPythonToCppValueConversion(typeStruct.type, pythonToCppFunc, isConvertibleToCppFunc);
+}
+
 PyObject *pointerToPython(PyTypeObject *type, const void *cppIn)
 {
     auto *sotp = PepType_SOTP(type);
@@ -228,6 +337,11 @@ PythonToCppConversion pythonToCppPointerConversion(PyTypeObject *type, PyObject
     return {};
 }
 
+PythonToCppConversion pythonToCppPointerConversion(Module::TypeInitStruct typeStruct, PyObject *pyIn)
+{
+    return pythonToCppPointerConversion(typeStruct.type, pyIn);
+}
+
 static inline PythonToCppFunc IsPythonToCppConvertible(const SbkConverter *converter, PyObject *pyIn)
 {
     assert(pyIn);
@@ -403,19 +517,55 @@ bool isImplicitConversion(PyTypeObject *type, PythonToCppFunc toCppFunc)
     return toCppFunc != (*conv).second;
 }
 
-void registerConverterName(SbkConverter *converter , const char *typeName)
+void registerConverterName(SbkConverter *converter, const char *typeName)
 {
     auto iter = converters.find(typeName);
     if (iter == converters.end())
         converters.insert(std::make_pair(typeName, converter));
 }
 
-SbkConverter *getConverter(const char *typeName)
+static std::string getRealTypeName(const std::string &typeName)
+{
+    auto size = typeName.size();
+    if (std::isalnum(typeName[size - 1]) == 0)
+        return typeName.substr(0, size - 1);
+    return typeName;
+}
+
+// PYSIDE-2404: Build a negative cache of already failed lookups.
+//              The resulting list must be reset after each new import,
+//              because that can change results. Also clear the cache after
+//              reaching some threashold.
+static std::unordered_set<std::string> nonExistingTypeNames{};
+
+// Arbitrary size limit to prevent random name overflows.
+static constexpr std::size_t negativeCacheLimit = 50;
+
+static void rememberAsNonexistent(const std::string &typeName)
+{
+    if (nonExistingTypeNames.size() > negativeCacheLimit)
+        clearNegativeLazyCache();
+    converters.insert(std::make_pair(typeName, nullptr));
+    nonExistingTypeNames.insert(typeName);
+}
+
+SbkConverter *getConverter(const char *typeNameC)
 {
-    ConvertersMap::const_iterator it = converters.find(typeName);
+    std::string typeName = typeNameC;
+    auto it = converters.find(typeName);
+    // PYSIDE-2404: This can also contain explicit nullptr as a negative cache.
+    if (it != converters.end())
+        return it->second;
+    // PYSIDE-2404: Did not find the name. Load the lazy classes
+    //              which have this name and try again.
+    Shiboken::Module::loadLazyClassesWithName(getRealTypeName(typeName).c_str());
+    it = converters.find(typeName);
     if (it != converters.end())
         return it->second;
-    if (Py_VerboseFlag > 0) {
+    // Cache the negative result. Don't forget to clear the cache for new modules.
+    rememberAsNonexistent(typeName);
+
+    if (Shiboken::pyVerbose() > 0) {
         const std::string message =
             std::string("Can't find type resolver for type '") + typeName + "'.";
         PyErr_WarnEx(PyExc_RuntimeWarning, message.c_str(), 0);
@@ -423,6 +573,15 @@ SbkConverter *getConverter(const char *typeName)
     return nullptr;
 }
 
+void clearNegativeLazyCache()
+{
+    for (const auto &typeName : nonExistingTypeNames) {
+        auto it = converters.find(typeName);
+        converters.erase(it);
+    }
+    nonExistingTypeNames.clear();
+}
+
 SbkConverter *primitiveTypeConverter(int index)
 {
     return PrimitiveTypeConverters[index];
@@ -748,4 +907,4 @@ void SpecificConverter::toCpp(PyObject *pyIn, void *cppOut)
     }
 }
 
-} } // namespace Shiboken::Conversions
+} // namespace Shiboken::Conversions
diff --git a/sources/shiboken6/libshiboken/sbkconverter.h b/sources/shiboken6/libshiboken/sbkconverter.h
index 1428b90e2..0d68f3faf 100644
--- a/sources/shiboken6/libshiboken/sbkconverter.h
+++ b/sources/shiboken6/libshiboken/sbkconverter.h
@@ -5,9 +5,9 @@
 #define SBK_CONVERTER_H
 
 #include "sbkpython.h"
+#include "sbkmodule.h"
 #include "shibokenmacros.h"
 #include "sbkenum.h"
-#include "sbkenum_p.h"
 #include "basewrapper_p.h"
 
 #include <limits>
@@ -43,7 +43,7 @@ struct SbkArrayConverter;
  *
  *  C++ -> Python
  */
-typedef PyObject *(*CppToPythonFunc)(const void *);
+using CppToPythonFunc = PyObject *(*)(const void *);
 
 /**
  *  This function converts a Python object to a C++ value, it may be
@@ -56,7 +56,7 @@ typedef PyObject *(*CppToPythonFunc)(const void *);
  *
  *  Python -> C++
  */
-typedef void (*PythonToCppFunc)(PyObject *,void *);
+using PythonToCppFunc = void (*)(PyObject *,void *);
 
 /**
  *  Checks if the Python object passed in the argument is convertible to a
@@ -67,7 +67,7 @@ typedef void (*PythonToCppFunc)(PyObject *,void *);
  *
  *  Python -> C++ ?
  */
-typedef PythonToCppFunc (*IsConvertibleToCppFunc)(PyObject *);
+using IsConvertibleToCppFunc = PythonToCppFunc (*)(PyObject *);
 
 } // extern "C"
 
@@ -147,6 +147,9 @@ LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkConverter *converter,
 LIBSHIBOKEN_API void addPythonToCppValueConversion(PyTypeObject *type,
                                                    PythonToCppFunc pythonToCppFunc,
                                                    IsConvertibleToCppFunc isConvertibleToCppFunc);
+LIBSHIBOKEN_API void addPythonToCppValueConversion(Shiboken::Module::TypeInitStruct typeStruct,
+                                                   PythonToCppFunc pythonToCppFunc,
+                                                   IsConvertibleToCppFunc isConvertibleToCppFunc);
 
 // C++ -> Python ---------------------------------------------------------------------------
 
@@ -204,6 +207,7 @@ struct PythonToCppConversion
  */
 LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(PyTypeObject *type, PyObject *pyIn);
 LIBSHIBOKEN_API PythonToCppConversion pythonToCppPointerConversion(PyTypeObject *type, PyObject *pyIn);
+LIBSHIBOKEN_API PythonToCppConversion pythonToCppPointerConversion(Module::TypeInitStruct typeStruct, PyObject *pyIn);
 
 /**
  *  Returns a Python to C++ conversion function if the Python object is convertible to a C++ value.
@@ -410,7 +414,7 @@ template<> inline PyTypeObject *SbkType<std::nullptr_t>() { return Py_TYPE(&_Py_
 #define SbkChar_Check(X) (PyNumber_Check(X) || Shiboken::String::checkChar(X))
 
 struct PySideQFlagsType;
-struct PySideQFlagsTypePrivate
+struct SbkQFlagsTypePrivate
 {
     SbkConverter *converter;
 };
diff --git a/sources/shiboken6/libshiboken/sbkconverter_p.h b/sources/shiboken6/libshiboken/sbkconverter_p.h
index 27126fbb1..08fc4c8e1 100644
--- a/sources/shiboken6/libshiboken/sbkconverter_p.h
+++ b/sources/shiboken6/libshiboken/sbkconverter_p.h
@@ -278,7 +278,7 @@ struct Primitive<PY_LONG_LONG> : OnePrimitive<PY_LONG_LONG>
     {
         PY_LONG_LONG result = PyLong_AsLongLong(pyIn);
         if (OverFlowChecker<PY_LONG_LONG>::check(result, pyIn))
-            PyErr_SetObject(PyExc_OverflowError, 0);
+            PyErr_SetObject(PyExc_OverflowError, nullptr);
         *reinterpret_cast<PY_LONG_LONG * >(cppOut) = result;
     }
     static PythonToCppFunc isConvertible(PyObject *pyIn)
@@ -327,7 +327,7 @@ struct FloatPrimitive : TwoPrimitive<FLOAT>
     }
     static void toCpp(PyObject *pyIn, void *cppOut)
     {
-        *reinterpret_cast<FLOAT *>(cppOut) = FLOAT(PyLong_AsLong(pyIn));
+        *reinterpret_cast<FLOAT *>(cppOut) = FLOAT(PyLong_AsDouble(pyIn));
     }
     static PythonToCppFunc isConvertible(PyObject *pyIn)
     {
@@ -524,13 +524,19 @@ struct Primitive<std::nullptr_t> : OnePrimitive<std::nullptr_t>
     }
 };
 
-namespace Shiboken {
-namespace Conversions {
+namespace Shiboken::Conversions {
+
 SbkConverter *createConverterObject(PyTypeObject *type,
                                     PythonToCppFunc toCppPointerConvFunc,
                                     IsConvertibleToCppFunc toCppPointerCheckFunc,
                                     CppToPythonFunc pointerToPythonFunc,
                                     CppToPythonFunc copyToPythonFunc);
-} // namespace Conversions
-} // namespace Shiboken
+
+LIBSHIBOKEN_API void dumpConverters();
+
+/// Interface for sbkmodule which must reset cache when new module is loaded.
+LIBSHIBOKEN_API void clearNegativeLazyCache();
+
+} // namespace Shiboken::Conversions
+
 #endif // SBK_CONVERTER_P_H
diff --git a/sources/shiboken6/libshiboken/sbkcppstring.cpp b/sources/shiboken6/libshiboken/sbkcppstring.cpp
index 42b09111c..8e8324f5e 100644
--- a/sources/shiboken6/libshiboken/sbkcppstring.cpp
+++ b/sources/shiboken6/libshiboken/sbkcppstring.cpp
@@ -12,6 +12,11 @@ PyObject *fromCppString(const std::string &value)
     return PyUnicode_FromStringAndSize(value.data(), value.size());
 }
 
+PyObject *fromCppStringView(std::string_view value)
+{
+    return PyUnicode_FromStringAndSize(value.data(), value.size());
+}
+
 PyObject *fromCppWString(const std::wstring &value)
 {
     return PyUnicode_FromWideChar(value.data(), value.size());
diff --git a/sources/shiboken6/libshiboken/sbkcppstring.h b/sources/shiboken6/libshiboken/sbkcppstring.h
index f418ea8dd..7ffe11c75 100644
--- a/sources/shiboken6/libshiboken/sbkcppstring.h
+++ b/sources/shiboken6/libshiboken/sbkcppstring.h
@@ -8,10 +8,12 @@
 #include "shibokenmacros.h"
 
 #include <string>
+#include <string_view>
 
 namespace Shiboken::String
 {
     LIBSHIBOKEN_API PyObject *fromCppString(const std::string &value);
+    LIBSHIBOKEN_API PyObject *fromCppStringView(std::string_view value);
     LIBSHIBOKEN_API PyObject *fromCppWString(const std::wstring &value);
     LIBSHIBOKEN_API void toCppString(PyObject *str, std::string *value);
     LIBSHIBOKEN_API void toCppWString(PyObject *str, std::wstring *value);
diff --git a/sources/shiboken6/libshiboken/sbkcpptonumpy.cpp b/sources/shiboken6/libshiboken/sbkcpptonumpy.cpp
index 44e900f01..7637efa70 100644
--- a/sources/shiboken6/libshiboken/sbkcpptonumpy.cpp
+++ b/sources/shiboken6/libshiboken/sbkcpptonumpy.cpp
@@ -49,17 +49,17 @@ PyObject *createByteArray1(Py_ssize_t, const uint8_t *)
 
 PyObject *createDoubleArray1(Py_ssize_t, const double *)
 {
-    return Py_None;
+    Py_RETURN_NONE;
 }
 
 PyObject *createFloatArray1(Py_ssize_t, const float *)
 {
-    return Py_None;
+    Py_RETURN_NONE;
 }
 
 PyObject *createIntArray1(Py_ssize_t, const int *)
 {
-    return Py_None;
+    Py_RETURN_NONE;
 }
 
 #endif // !HAVE_NUMPY
diff --git a/sources/shiboken6/libshiboken/sbkenum.cpp b/sources/shiboken6/libshiboken/sbkenum.cpp
index 4bac1c9a5..2b083a91c 100644
--- a/sources/shiboken6/libshiboken/sbkenum.cpp
+++ b/sources/shiboken6/libshiboken/sbkenum.cpp
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #include "sbkenum.h"
-#include "sbkenum_p.h"
 #include "sbkstring.h"
 #include "sbkstaticstrings.h"
 #include "sbkstaticstrings_p.h"
@@ -16,386 +15,23 @@
 #include <vector>
 #include <sstream>
 
-#define SbkEnumType_Check(o) (Py_TYPE(Py_TYPE(o)) == SbkEnumType_TypeF())
-using enum_func = PyObject *(*)(PyObject *, PyObject *);
-
 using namespace Shiboken;
 
 extern "C"
 {
 
-// forward
-struct lastEnumCreated;
-
-// forward
-static PyTypeObject *recordCurrentEnum(PyObject *scopeOrModule,
-                                       const char *name,
-                                       PyTypeObject *enumType,
-                                       PyTypeObject *flagsType);
-
 struct SbkEnumType
 {
     PyTypeObject type;
 };
 
-static void cleanupEnumTypes();
-
-struct SbkEnumObject
-{
-    PyObject_HEAD
-    Enum::EnumValueType ob_value;
-    PyObject *ob_name;
-};
-
-static PyTypeObject *SbkEnum_TypeF();   // forward
-
-static PyObject *SbkEnumObject_repr(PyObject *self)
-{
-    const SbkEnumObject *enumObj = reinterpret_cast<SbkEnumObject *>(self);
-    auto name = Py_TYPE(self)->tp_name;
-    if (enumObj->ob_name) {
-        return String::fromFormat("%s.%s", name, PyBytes_AS_STRING(enumObj->ob_name));
-    }
-    return String::fromFormat("%s(%ld)", name, enumObj->ob_value);
-}
-
-static PyObject *SbkEnumObject_name(PyObject *self, void *)
-{
-    auto *enum_self = reinterpret_cast<SbkEnumObject *>(self);
-
-    if (enum_self->ob_name == nullptr)
-        Py_RETURN_NONE;
-
-    Py_INCREF(enum_self->ob_name);
-    return enum_self->ob_name;
-}
-
-static PyObject *SbkEnum_tp_new(PyTypeObject *type, PyObject *args, PyObject *)
-{
-    long itemValue = 0;
-    if (!PyArg_ParseTuple(args, "|l:__new__", &itemValue))
-        return nullptr;
-
-    if (type == SbkEnum_TypeF()) {
-        PyErr_Format(PyExc_TypeError, "You cannot use %s directly", type->tp_name);
-        return nullptr;
-    }
-
-    SbkEnumObject *self = PyObject_New(SbkEnumObject, type);
-    if (!self)
-        return nullptr;
-    self->ob_value = itemValue;
-    AutoDecRef item(Enum::getEnumItemFromValue(type, itemValue));
-    self->ob_name = item.object() ? SbkEnumObject_name(item, nullptr) : nullptr;
-    return reinterpret_cast<PyObject *>(self);
-}
-
-static const char *SbkEnum_SignatureStrings[] = {
-    "Shiboken.Enum(self,itemValue:int=0)",
-    nullptr}; // Sentinel
-
-static void enum_object_dealloc(PyObject *ob)
-{
-    auto *self = reinterpret_cast<SbkEnumObject *>(ob);
-    Py_XDECREF(self->ob_name);
-    Sbk_object_dealloc(ob);
-}
-
-static PyObject *_enum_op(enum_func f, PyObject *a, PyObject *b) {
-    PyObject *valA = a;
-    PyObject *valB = b;
-    PyObject *result = nullptr;
-    bool enumA = false;
-    bool enumB = false;
-
-    // We are not allowing floats
-    if (!PyFloat_Check(valA) && !PyFloat_Check(valB)) {
-        // Check if both variables are SbkEnumObject
-        if (SbkEnumType_Check(valA)) {
-            valA = PyLong_FromLong(reinterpret_cast<SbkEnumObject *>(valA)->ob_value);
-            enumA = true;
-        }
-        if (SbkEnumType_Check(valB)) {
-            valB = PyLong_FromLong(reinterpret_cast<SbkEnumObject *>(valB)->ob_value);
-            enumB = true;
-        }
-    }
-
-    // Without an enum we are not supporting the operation
-    if (!(enumA || enumB)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
-
-    result = f(valA, valB);
-
-    // Decreasing the reference of the used variables a and b.
-    if (enumA)
-        Py_DECREF(valA);
-    if (enumB)
-        Py_DECREF(valB);
-    return result;
-}
-
-/* Notes:
- *   On Py3k land we use long type when using integer numbers. However, on older
- *   versions of Python (version 2) we need to convert it to int type,
- *   respectively.
- *
- *   Thus calling PyLong_FromLong() will result in calling PyLong_FromLong in
- *   Py3k.
- */
-static PyObject *enum_int(PyObject *v)
-{
-    return PyLong_FromLong(reinterpret_cast<SbkEnumObject *>(v)->ob_value);
-}
-
-static PyObject *enum_and(PyObject *self, PyObject *b)
-{
-    return _enum_op(PyNumber_And, self, b);
-}
-
-static PyObject *enum_or(PyObject *self, PyObject *b)
-{
-    return _enum_op(PyNumber_Or, self, b);
-}
-
-static PyObject *enum_xor(PyObject *self, PyObject *b)
-{
-    return _enum_op(PyNumber_Xor, self, b);
-}
-
-static int enum_bool(PyObject *v)
-{
-    return (reinterpret_cast<SbkEnumObject *>(v)->ob_value > 0);
-}
-
-static PyObject *enum_add(PyObject *self, PyObject *v)
-{
-    return _enum_op(PyNumber_Add, self, v);
-}
-
-static PyObject *enum_subtract(PyObject *self, PyObject *v)
-{
-    return _enum_op(PyNumber_Subtract, self, v);
-}
-
-static PyObject *enum_multiply(PyObject *self, PyObject *v)
-{
-    return _enum_op(PyNumber_Multiply, self, v);
-}
-
-static PyObject *enum_richcompare(PyObject *self, PyObject *other, int op)
-{
-    PyObject *valA = self;
-    PyObject *valB = other;
-    PyObject *result = nullptr;
-    bool enumA = false;
-    bool enumB = false;
-
-    // We are not allowing floats
-    if (!PyFloat_Check(valA) && !PyFloat_Check(valB)) {
-
-        // Check if both variables are SbkEnumObject
-        if (SbkEnumType_Check(valA)) {
-            valA = PyLong_FromLong(reinterpret_cast<SbkEnumObject *>(valA)->ob_value);
-            enumA = true;
-        }
-        if (SbkEnumType_Check(valB)) {
-            valB = PyLong_FromLong(reinterpret_cast<SbkEnumObject *>(valB)->ob_value);
-            enumB =true;
-        }
-    }
-
-    // Without an enum we are not supporting the operation
-    if (!(enumA || enumB)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
-    result = PyObject_RichCompare(valA, valB, op);
-
-    // Decreasing the reference of the used variables a and b.
-    if (enumA)
-        Py_DECREF(valA);
-    if (enumB)
-        Py_DECREF(valB);
-
-    return result;
-}
-
-static Py_hash_t enum_hash(PyObject *pyObj)
-{
-    Py_hash_t val = reinterpret_cast<SbkEnumObject *>(pyObj)->ob_value;
-    if (val == -1)
-        val = -2;
-    return val;
-}
-
-static PyGetSetDef SbkEnumGetSetList[] = {
-    {const_cast<char *>("name"), SbkEnumObject_name, nullptr, nullptr, nullptr},
-    {nullptr, nullptr, nullptr, nullptr, nullptr} // Sentinel
-};
-
-static void SbkEnumTypeDealloc(PyObject *pyObj);
-static PyTypeObject *SbkEnumTypeTpNew(PyTypeObject *metatype, PyObject *args, PyObject *kwds);
-
-static PyGetSetDef SbkEnumType_getsetlist[] = {
-    {const_cast<char *>("__signature__"), reinterpret_cast<getter>(Sbk_TypeGet___signature__),
-                                          nullptr, nullptr, nullptr},
-    {nullptr, nullptr, nullptr, nullptr, nullptr}  // Sentinel
-};
-
-static PyType_Slot SbkEnumType_Type_slots[] = {
-    {Py_tp_dealloc, reinterpret_cast<void *>(SbkEnumTypeDealloc)},
-    {Py_tp_base, reinterpret_cast<void *>(&PyType_Type)},
-    {Py_tp_alloc, reinterpret_cast<void *>(PyType_GenericAlloc)},
-    {Py_tp_new, reinterpret_cast<void *>(SbkEnumTypeTpNew)},
-    {Py_tp_free, reinterpret_cast<void *>(PyObject_GC_Del)},
-    {Py_tp_getset, reinterpret_cast<void *>(SbkEnumType_getsetlist)},
-    {0, nullptr}
-};
-
-// PYSIDE-535: The tp_itemsize field is inherited and does not need to be set.
-// In PyPy, it _must_ not be set, because it would have the meaning that a
-// `__len__` field must be defined. Not doing so creates a hard-to-find crash.
-static PyType_Spec SbkEnumType_Type_spec = {
-    "1:Shiboken.EnumMeta",
-    0,
-    0, // sizeof(PyMemberDef), not for PyPy without a __len__ defined
-    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
-    SbkEnumType_Type_slots,
-};
-
-PyTypeObject *SbkEnumType_TypeF(void)
-{
-    static auto *type = SbkType_FromSpec(&SbkEnumType_Type_spec);
-    return type;
-}
-
-static void SbkEnumTypeDealloc(PyObject *pyObj)
-{
-    auto *enumType = reinterpret_cast<SbkEnumType *>(pyObj);
-    auto *setp = PepType_SETP(enumType);
-
-    PyObject_GC_UnTrack(pyObj);
-#ifndef Py_LIMITED_API
-#  if PY_VERSION_HEX >= 0x030A0000
-    Py_TRASHCAN_BEGIN(pyObj, 1);
-#  else
-    Py_TRASHCAN_SAFE_BEGIN(pyObj);
-#  endif
-#endif
-    if (setp->converter)
-        Conversions::deleteConverter(setp->converter);
-    PepType_SETP_delete(enumType);
-#ifndef Py_LIMITED_API
-#  if PY_VERSION_HEX >= 0x030A0000
-    Py_TRASHCAN_END;
-#  else
-    Py_TRASHCAN_SAFE_END(pyObj);
-#  endif
-#endif
-    if (PepRuntime_38_flag) {
-        // PYSIDE-939: Handling references correctly.
-        // This was not needed before Python 3.8 (Python issue 35810)
-        Py_DECREF(Py_TYPE(pyObj));
-    }
-}
-
-PyTypeObject *SbkEnumTypeTpNew(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
-{
-    init_enum();
-    return PepType_Type_tp_new(metatype, args, kwds);
-}
-
-} // extern "C"
-
-///////////////////////////////////////////////////////////////
-//
-// PYSIDE-15: Pickling Support for Qt Enum objects
-//            This works very well and fixes the issue.
-//
-extern "C" {
-
-static PyObject *enum_unpickler = nullptr;
-
-// Pickling: reduce the Qt Enum object
-static PyObject *enum___reduce__(PyObject *obj)
-{
-    init_enum();
-    return Py_BuildValue("O(Ni)",
-                         enum_unpickler,
-                         Py_BuildValue("s", Py_TYPE(obj)->tp_name),
-                         PyLong_AS_LONG(obj));
-}
-
-} // extern "C"
-
-namespace Shiboken { namespace Enum {
-
-// Unpickling: rebuild the Qt Enum object
-PyObject *unpickleEnum(PyObject *enum_class_name, PyObject *value)
-{
-    AutoDecRef parts(PyObject_CallMethod(enum_class_name,
-                               "split", "s", "."));
-    if (parts.isNull())
-        return nullptr;
-    PyObject *top_name = PyList_GetItem(parts, 0); // borrowed ref
-    if (top_name == nullptr)
-        return nullptr;
-    PyObject *module = PyImport_GetModule(top_name);
-    if (module == nullptr) {
-        PyErr_Format(PyExc_ImportError, "could not import module %.200s",
-            String::toCString(top_name));
-        return nullptr;
-    }
-    AutoDecRef cur_thing(module);
-    int len = PyList_Size(parts);
-    for (int idx = 1; idx < len; ++idx) {
-        PyObject *name = PyList_GetItem(parts, idx); // borrowed ref
-        PyObject *thing = PyObject_GetAttr(cur_thing, name);
-        if (thing == nullptr) {
-            PyErr_Format(PyExc_ImportError, "could not import Qt Enum type %.200s",
-                String::toCString(enum_class_name));
-            return nullptr;
-        }
-        cur_thing.reset(thing);
-    }
-    PyObject *klass = cur_thing;
-    return PyObject_CallFunctionObjArgs(klass, value, nullptr);
-}
-
-int enumOption{};
-
-} // namespace Enum
-} // namespace Shiboken
-
-extern "C" {
-
 // Initialization
 static bool _init_enum()
 {
     AutoDecRef shibo(PyImport_ImportModule("shiboken6.Shiboken"));
-    auto mod = shibo.object();
-    // publish Shiboken.Enum so that the signature gets initialized
-    if (PyObject_SetAttrString(mod, "Enum", reinterpret_cast<PyObject *>(SbkEnum_TypeF())) < 0)
-        return false;
-    if (InitSignatureStrings(SbkEnum_TypeF(), SbkEnum_SignatureStrings) < 0)
-        return false;
-    enum_unpickler = PyObject_GetAttrString(mod, "_unpickle_enum");
-    if (enum_unpickler == nullptr)
-        return false;
-    return true;
+    return !shibo.isNull();
 }
 
-static int useOldEnum = -1;
-
-static PyMethodDef SbkEnumObject_Methods[] = {
-    {"__reduce__", reinterpret_cast<PyCFunction>(enum___reduce__),
-        METH_NOARGS, nullptr},
-    {nullptr, nullptr, 0, nullptr} // Sentinel
-};
-
 static PyObject *PyEnumModule{};
 static PyObject *PyEnumMeta{};
 static PyObject *PyEnum{};
@@ -406,8 +42,7 @@ static PyObject *PyFlag_KEEP{};
 
 bool PyEnumMeta_Check(PyObject *ob)
 {
-    return Py_TYPE(ob) == (useOldEnum ? SbkEnumType_TypeF()
-                                      : reinterpret_cast<PyTypeObject *>(PyEnumMeta));
+    return Py_TYPE(ob) == reinterpret_cast<PyTypeObject *>(PyEnumMeta);
 }
 
 PyTypeObject *getPyEnumMeta()
@@ -443,20 +78,17 @@ void init_enum()
     static bool isInitialized = false;
     if (isInitialized)
         return;
-    if (!(isInitialized || enum_unpickler || _init_enum()))
-        Py_FatalError("could not load enum pickling helper function");
-    Py_AtExit(cleanupEnumTypes);
+    if (!(isInitialized || _init_enum()))
+        Py_FatalError("could not init enum");
 
     // PYSIDE-1735: Determine whether we should use the old or the new enum implementation.
-    static PyObject *sysmodule = PyImport_AddModule("sys");
-    static PyObject *option = PyObject_GetAttrString(sysmodule, "pyside63_option_python_enum");
+    static PyObject *option = PySys_GetObject("pyside6_option_python_enum");
     if (!option || !PyLong_Check(option)) {
         PyErr_Clear();
-        option = PyLong_FromLong(0);
+        option = PyLong_FromLong(1);
     }
     int ignoreOver{};
     Enum::enumOption = PyLong_AsLongAndOverflow(option, &ignoreOver);
-    useOldEnum = Enum::enumOption == Enum::ENOPT_OLD_ENUM;
     getPyEnumMeta();
     isInitialized = true;
 }
@@ -470,8 +102,8 @@ int enumIsFlag(PyObject *ob_type)
     if (metatype != reinterpret_cast<PyTypeObject *>(PyEnumMeta))
         return -1;
     auto *mro = reinterpret_cast<PyTypeObject *>(ob_type)->tp_mro;
-    Py_ssize_t idx, n = PyTuple_GET_SIZE(mro);
-    for (idx = 0; idx < n; idx++) {
+    const Py_ssize_t n = PyTuple_GET_SIZE(mro);
+    for (Py_ssize_t idx = 0; idx < n; ++idx) {
         auto *sub_type = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
         if (sub_type == reinterpret_cast<PyTypeObject *>(PyFlag))
             return 1;
@@ -479,516 +111,6 @@ int enumIsFlag(PyObject *ob_type)
     return 0;
 }
 
-// PYSIDE-1735: Helper function to ask what enum we are using
-bool usingNewEnum()
-{
-    init_enum();
-    return !useOldEnum;
-}
-
-} // extern "C"
-
-//
-///////////////////////////////////////////////////////////////
-
-namespace Shiboken {
-
-class DeclaredEnumTypes
-{
-public:
-    struct EnumEntry
-    {
-        char *name; // full name as allocated. type->tp_name might be a substring.
-        PyTypeObject *type;
-    };
-
-    DeclaredEnumTypes(const DeclaredEnumTypes &) = delete;
-    DeclaredEnumTypes(DeclaredEnumTypes &&) = delete;
-    DeclaredEnumTypes &operator=(const DeclaredEnumTypes &) = delete;
-    DeclaredEnumTypes &operator=(DeclaredEnumTypes &&) = delete;
-
-    DeclaredEnumTypes();
-    ~DeclaredEnumTypes();
-    static DeclaredEnumTypes &instance();
-    void addEnumType(const EnumEntry &e) { m_enumTypes.push_back(e); }
-
-    void cleanup();
-
-private:
-    std::vector<EnumEntry> m_enumTypes;
-};
-
-namespace Enum {
-
-// forward
-static PyObject *newItemOld(PyTypeObject *enumType, EnumValueType itemValue,
-                            const char *itemName);
-
-// forward
-static PyTypeObject * newTypeWithNameOld(const char *name,
-                                         const char *cppName,
-                                         PyTypeObject *numbers_fromFlag);
-
-bool check(PyObject *pyObj)
-{
-    init_enum();
-
-    // PYSIDE-1735: Decide dynamically if new or old enums will be used.
-    if (useOldEnum)
-        return Py_TYPE(Py_TYPE(pyObj)) == SbkEnumType_TypeF();
-
-    static PyTypeObject *meta = getPyEnumMeta();
-    return Py_TYPE(Py_TYPE(pyObj)) == reinterpret_cast<PyTypeObject *>(meta);
-}
-
-static PyObject *getEnumItemFromValueOld(PyTypeObject *enumType,
-                                         EnumValueType itemValue)
-{
-    PyObject *key, *value;
-    Py_ssize_t pos = 0;
-    PyObject *values = PyDict_GetItem(enumType->tp_dict, PyName::values());
-    if (values == nullptr)
-        return nullptr;
-
-    while (PyDict_Next(values, &pos, &key, &value)) {
-        auto *obj = reinterpret_cast<SbkEnumObject *>(value);
-        if (obj->ob_value == itemValue) {
-            Py_INCREF(value);
-            return value;
-        }
-    }
-    return nullptr;
-}
-
-PyObject *getEnumItemFromValue(PyTypeObject *enumType, EnumValueType itemValue)
-{
-    init_enum();
-    // PYSIDE-1735: Decide dynamically if new or old enums will be used.
-    if (useOldEnum)
-        return getEnumItemFromValueOld(enumType, itemValue);
-
-    auto *obEnumType = reinterpret_cast<PyObject *>(enumType);
-    AutoDecRef val2members(PyObject_GetAttrString(obEnumType, "_value2member_map_"));
-    if (val2members.isNull()) {
-        PyErr_Clear();
-        return nullptr;
-    }
-    AutoDecRef ob_value(PyLong_FromLongLong(itemValue));
-    auto *result = PyDict_GetItem(val2members, ob_value);
-    Py_XINCREF(result);
-    return result;
-}
-
-static PyTypeObject *createEnum(const char *fullName, const char *cppName,
-                                PyTypeObject *flagsType)
-{
-    init_enum();
-    PyTypeObject *enumType = newTypeWithNameOld(fullName, cppName, flagsType);
-    if (PyType_Ready(enumType) < 0) {
-        Py_XDECREF(enumType);
-        return nullptr;
-    }
-    return enumType;
-}
-
-PyTypeObject *createGlobalEnum(PyObject *module, const char *name, const char *fullName,
-                               const char *cppName, PyTypeObject *flagsType)
-{
-    PyTypeObject *enumType = createEnum(fullName, cppName, flagsType);
-    if (enumType && PyModule_AddObject(module, name, reinterpret_cast<PyObject *>(enumType)) < 0) {
-        Py_DECREF(enumType);
-        return nullptr;
-    }
-    flagsType = recordCurrentEnum(module, name, enumType, flagsType);
-    if (flagsType && PyModule_AddObject(module, PepType_GetNameStr(flagsType),
-            reinterpret_cast<PyObject *>(flagsType)) < 0) {
-        Py_DECREF(enumType);
-        return nullptr;
-    }
-    return enumType;
-}
-
-PyTypeObject *createScopedEnum(PyTypeObject *scope, const char *name, const char *fullName,
-                               const char *cppName, PyTypeObject *flagsType)
-{
-    PyTypeObject *enumType = createEnum(fullName, cppName, flagsType);
-    if (enumType && PyDict_SetItemString(scope->tp_dict, name,
-            reinterpret_cast<PyObject *>(enumType)) < 0) {
-        Py_DECREF(enumType);
-        return nullptr;
-    }
-    auto *obScope = reinterpret_cast<PyObject *>(scope);
-    flagsType = recordCurrentEnum(obScope, name, enumType, flagsType);
-    if (flagsType && PyDict_SetItemString(scope->tp_dict,
-            PepType_GetNameStr(flagsType),
-            reinterpret_cast<PyObject *>(flagsType)) < 0) {
-        Py_DECREF(enumType);
-        return nullptr;
-    }
-    return enumType;
-}
-
-static PyObject *createEnumItem(PyTypeObject *enumType, const char *itemName,
-                                EnumValueType itemValue)
-{
-    init_enum();
-    PyObject *enumItem = newItemOld(enumType, itemValue, itemName);
-    if (PyDict_SetItemString(enumType->tp_dict, itemName, enumItem) < 0) {
-        Py_DECREF(enumItem);
-        return nullptr;
-    }
-    return enumItem;
-}
-
-bool createGlobalEnumItem(PyTypeObject *enumType, PyObject *module,
-                          const char *itemName, EnumValueType itemValue)
-{
-    PyObject *enumItem = createEnumItem(enumType, itemName, itemValue);
-    if (!enumItem)
-        return false;
-    int ok = useOldEnum ? PyModule_AddObject(module, itemName, enumItem) : true;
-    Py_DECREF(enumItem);
-    return ok >= 0;
-}
-
-bool createScopedEnumItem(PyTypeObject *enumType, PyTypeObject *scope,
-                          const char *itemName, EnumValueType itemValue)
-{
-    PyObject *enumItem = createEnumItem(enumType, itemName, itemValue);
-    if (!enumItem)
-        return false;
-    int ok = useOldEnum ? PyDict_SetItemString(scope->tp_dict, itemName, enumItem) : true;
-    Py_DECREF(enumItem);
-    return ok >= 0;
-}
-
-// This exists temporary as the old way to create an enum item.
-// For the public interface, we use a new function
-static PyObject *newItemOld(PyTypeObject *enumType,
-                            EnumValueType itemValue, const char *itemName)
-{
-    bool newValue = true;
-    SbkEnumObject *enumObj;
-    if (!itemName) {
-        enumObj = reinterpret_cast<SbkEnumObject *>(
-                      getEnumItemFromValue(enumType, itemValue));
-        if (enumObj)
-            return reinterpret_cast<PyObject *>(enumObj);
-
-        newValue = false;
-    }
-
-    enumObj = PyObject_New(SbkEnumObject, enumType);
-    if (!enumObj)
-        return nullptr;
-
-    enumObj->ob_name = itemName ? PyBytes_FromString(itemName) : nullptr;
-    enumObj->ob_value = itemValue;
-
-    if (newValue) {
-        auto dict = enumType->tp_dict;  // Note: 'values' is borrowed
-        PyObject *values = PyDict_GetItemWithError(dict, PyName::values());
-        if (values == nullptr) {
-            if (PyErr_Occurred())
-                return nullptr;
-            AutoDecRef new_values(values = PyDict_New());
-            if (values == nullptr)
-                return nullptr;
-            if (PyDict_SetItem(dict, PyName::values(), values) < 0)
-                return nullptr;
-        }
-        PyDict_SetItemString(values, itemName, reinterpret_cast<PyObject *>(enumObj));
-    }
-
-    return reinterpret_cast<PyObject *>(enumObj);
-}
-
-PyObject *newItem(PyTypeObject *enumType, EnumValueType itemValue,
-                  const char *itemName)
-{
-    init_enum();
-    // PYSIDE-1735: Decide dynamically if new or old enums will be used.
-    if (useOldEnum)
-        return newItemOld(enumType, itemValue, itemName);
-
-    auto *obEnumType = reinterpret_cast<PyObject *>(enumType);
-    if (!itemName)
-        return PyObject_CallFunction(obEnumType, "L", itemValue);
-
-    static PyObject *const _member_map_ = String::createStaticString("_member_map_");
-    auto *member_map = PyDict_GetItem(enumType->tp_dict, _member_map_);
-    if (!(member_map && PyDict_Check(member_map)))
-        return nullptr;
-    auto *result = PyDict_GetItemString(member_map, itemName);
-    Py_XINCREF(result);
-    return result;
-}
-
-} // namespace Shiboken
-} // namespace Enum
-
-static PyType_Slot SbkNewEnum_slots[] = {
-    {Py_tp_repr, reinterpret_cast<void *>(SbkEnumObject_repr)},
-    {Py_tp_str, reinterpret_cast<void *>(SbkEnumObject_repr)},
-    {Py_tp_getset, reinterpret_cast<void *>(SbkEnumGetSetList)},
-    {Py_tp_methods, reinterpret_cast<void *>(SbkEnumObject_Methods)},
-    {Py_tp_new, reinterpret_cast<void *>(SbkEnum_tp_new)},
-    {Py_nb_add, reinterpret_cast<void *>(enum_add)},
-    {Py_nb_subtract, reinterpret_cast<void *>(enum_subtract)},
-    {Py_nb_multiply, reinterpret_cast<void *>(enum_multiply)},
-    {Py_nb_positive, reinterpret_cast<void *>(enum_int)},
-    {Py_nb_bool, reinterpret_cast<void *>(enum_bool)},
-    {Py_nb_and, reinterpret_cast<void *>(enum_and)},
-    {Py_nb_xor, reinterpret_cast<void *>(enum_xor)},
-    {Py_nb_or, reinterpret_cast<void *>(enum_or)},
-    {Py_nb_int, reinterpret_cast<void *>(enum_int)},
-    {Py_nb_index, reinterpret_cast<void *>(enum_int)},
-    {Py_tp_richcompare, reinterpret_cast<void *>(enum_richcompare)},
-    {Py_tp_hash, reinterpret_cast<void *>(enum_hash)},
-    {Py_tp_dealloc, reinterpret_cast<void *>(enum_object_dealloc)},
-    {0, nullptr}
-};
-static PyType_Spec SbkNewEnum_spec = {
-    "1:Shiboken.Enum",
-    sizeof(SbkEnumObject),
-    0,
-    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
-    SbkNewEnum_slots,
-};
-
-static PyTypeObject *SbkEnum_TypeF()
-{
-    static auto type = SbkType_FromSpecWithMeta(&SbkNewEnum_spec, SbkEnumType_TypeF());
-    return type;
-}
-
-namespace Shiboken { namespace Enum {
-
-static void
-copyNumberMethods(PyTypeObject *flagsType,
-                  PyType_Slot number_slots[],
-                  int *pidx)
-{
-    int idx = *pidx;
-#define PUT_SLOT(name) \
-    number_slots[idx].slot = (name);                                \
-    number_slots[idx].pfunc = PyType_GetSlot(flagsType, (name));    \
-    ++idx;
-
-    PUT_SLOT(Py_nb_absolute);
-    PUT_SLOT(Py_nb_add);
-    PUT_SLOT(Py_nb_and);
-    PUT_SLOT(Py_nb_bool);
-    PUT_SLOT(Py_nb_divmod);
-    PUT_SLOT(Py_nb_float);
-    PUT_SLOT(Py_nb_floor_divide);
-    PUT_SLOT(Py_nb_index);
-    PUT_SLOT(Py_nb_inplace_add);
-    PUT_SLOT(Py_nb_inplace_and);
-    PUT_SLOT(Py_nb_inplace_floor_divide);
-    PUT_SLOT(Py_nb_inplace_lshift);
-    PUT_SLOT(Py_nb_inplace_multiply);
-    PUT_SLOT(Py_nb_inplace_or);
-    PUT_SLOT(Py_nb_inplace_power);
-    PUT_SLOT(Py_nb_inplace_remainder);
-    PUT_SLOT(Py_nb_inplace_rshift);
-    PUT_SLOT(Py_nb_inplace_subtract);
-    PUT_SLOT(Py_nb_inplace_true_divide);
-    PUT_SLOT(Py_nb_inplace_xor);
-    PUT_SLOT(Py_nb_int);
-    PUT_SLOT(Py_nb_invert);
-    PUT_SLOT(Py_nb_lshift);
-    PUT_SLOT(Py_nb_multiply);
-    PUT_SLOT(Py_nb_negative);
-    PUT_SLOT(Py_nb_or);
-    PUT_SLOT(Py_nb_positive);
-    PUT_SLOT(Py_nb_power);
-    PUT_SLOT(Py_nb_remainder);
-    PUT_SLOT(Py_nb_rshift);
-    PUT_SLOT(Py_nb_subtract);
-    PUT_SLOT(Py_nb_true_divide);
-    PUT_SLOT(Py_nb_xor);
-#undef PUT_SLOT
-    *pidx = idx;
-}
-
-static PyTypeObject * newTypeWithNameOld(const char *name,
-                                         const char *cppName,
-                                         PyTypeObject *numbers_fromFlag)
-{
-    // Careful: SbkType_FromSpec does not allocate the string.
-    PyType_Slot newslots[99] = {};  // enough but not too big for the stack
-    PyType_Spec newspec;
-    DeclaredEnumTypes::EnumEntry entry{strdup(name), nullptr};
-    newspec.name = entry.name; // Note that SbkType_FromSpec might use a substring.
-    newspec.basicsize = SbkNewEnum_spec.basicsize;
-    newspec.itemsize = SbkNewEnum_spec.itemsize;
-    newspec.flags = SbkNewEnum_spec.flags;
-    // we must append all the number methods, so rebuild everything:
-    int idx = 0;
-    while (SbkNewEnum_slots[idx].slot) {
-        newslots[idx].slot = SbkNewEnum_slots[idx].slot;
-        newslots[idx].pfunc = SbkNewEnum_slots[idx].pfunc;
-        ++idx;
-    }
-    if (numbers_fromFlag)
-        copyNumberMethods(numbers_fromFlag, newslots, &idx);
-    newspec.slots = newslots;
-    AutoDecRef bases(PyTuple_New(1));
-    static auto basetype = reinterpret_cast<PyObject *>(SbkEnum_TypeF());
-    Py_INCREF(basetype);
-    PyTuple_SetItem(bases, 0, basetype);
-    auto *type = SbkType_FromSpecBasesMeta(&newspec, bases, SbkEnumType_TypeF());
-    entry.type = type;
-
-    auto *enumType = reinterpret_cast<SbkEnumType *>(type);
-    auto *setp = PepType_SETP(enumType);
-    setp->cppName = cppName;
-    DeclaredEnumTypes::instance().addEnumType(entry);
-    return entry.type;
-}
-
-// PySIDE-1735: This function is in the API and should be removed in 6.4 .
-//              Python enums are created differently.
-PyTypeObject *newTypeWithName(const char *name,
-                              const char *cppName,
-                              PyTypeObject *numbers_fromFlag)
-{
-    if (!useOldEnum)
-        PyErr_Format(PyExc_RuntimeError, "function `%s` can no longer be used when the Python "
-            "Enum's have been selected", __FUNCTION__);
-    return newTypeWithNameOld(name, cppName, numbers_fromFlag);
-}
-
-const char *getCppName(PyTypeObject *enumType)
-{
-    assert(Py_TYPE(enumType) == SbkEnumType_TypeF());
-    auto *type = reinterpret_cast<SbkEnumType *>(enumType);
-    auto *setp = PepType_SETP(type);
-    return setp->cppName;
-}
-
-EnumValueType getValue(PyObject *enumItem)
-{
-    init_enum();
-
-    assert(Enum::check(enumItem));
-
-    // PYSIDE-1735: Decide dynamically if new or old enums will be used.
-    if (useOldEnum)
-        return reinterpret_cast<SbkEnumObject *>(enumItem)->ob_value;
-
-    AutoDecRef pyValue(PyObject_GetAttrString(enumItem, "value"));
-    return PyLong_AsLongLong(pyValue);
-}
-
-void setTypeConverter(PyTypeObject *type, SbkConverter *converter, bool isFlag)
-{
-    if (isFlag) {
-        auto *flagsType = reinterpret_cast<PySideQFlagsType *>(type);
-        PepType_PFTP(flagsType)->converter = converter;
-    }
-    else {
-        auto *enumType = reinterpret_cast<SbkEnumType *>(type);
-        PepType_SETP(enumType)->converter = converter;
-    }
-}
-
-} // namespace Enum
-
-DeclaredEnumTypes &DeclaredEnumTypes::instance()
-{
-    static DeclaredEnumTypes me;
-    return me;
-}
-
-DeclaredEnumTypes::DeclaredEnumTypes() = default;
-
-DeclaredEnumTypes::~DeclaredEnumTypes()
-{
-   cleanup();
-}
-
-void DeclaredEnumTypes::cleanup()
-{
-    static bool was_called = false;
-    if (was_called)
-        return;
-
-    for (const auto &e : m_enumTypes) {
-        std::free(e.name);
-    }
-    m_enumTypes.clear();
-    was_called = true;
-}
-
-} // namespace Shiboken
-
-static void cleanupEnumTypes()
-{
-    DeclaredEnumTypes::instance().cleanup();
-}
-
-///////////////////////////////////////////////////////////////////////
-//
-// PYSIDE-1735: Re-implementation of Enums using Python
-// ====================================================
-//
-// This is a very simple, first implementation of a replacement
-// for the Qt-like Enums using the Python Enum module.
-//
-// The basic idea:
-// ---------------
-// * We create the Enums as always
-// * After creation of each enum, a special function is called that
-//   * grabs the last generated enum
-//   * reads all Enum items
-//   * generates a class statement for the Python Enum
-//   * creates a new Python Enum class
-//   * replaces the already inserted Enum with the new one.
-//
-// There are lots of ways to optimize that. Will be added later.
-//
-extern "C" {
-
-struct lastEnumCreated {
-    PyObject *scopeOrModule;
-    const char *name;
-    PyTypeObject *enumType;
-    PyTypeObject *flagsType;
-};
-
-static lastEnumCreated lec{};
-
-static PyTypeObject *recordCurrentEnum(PyObject *scopeOrModule,
-                                       const char *name,
-                                       PyTypeObject *enumType,
-                                       PyTypeObject *flagsType)
-{
-    lec.scopeOrModule = scopeOrModule;
-    lec.name = name;
-    lec.enumType = enumType;
-    lec.flagsType = flagsType;
-
-    // PYSIDE-1735: Decide dynamically if new or old enums will be used.
-    if (useOldEnum)
-        return flagsType;
-
-    // We return nullptr as flagsType to disable flag creation.
-    return nullptr;
-}
-
-static bool is_old_version()
-{
-    auto *sysmodule = PyImport_AddModule("sys");
-    auto *dic = PyModule_GetDict(sysmodule);
-    auto *version = PyDict_GetItemString(dic, "version_info");
-    auto *major = PyTuple_GetItem(version, 0);
-    auto *minor = PyTuple_GetItem(version, 1);
-    auto number = PyLong_AsLong(major) * 1000 + PyLong_AsLong(minor);
-    return number <= 3008;
-}
-
 ///////////////////////////////////////////////////////////////////////
 //
 // Support for Missing Values
@@ -1010,6 +132,7 @@ static bool is_old_version()
 // We create each constant only once and keep the result in a dict
 // "_sbk_missing_". This is similar to a competitor's "_sip_missing_".
 //
+
 static PyObject *missing_func(PyObject * /* self */ , PyObject *args)
 {
     // In order to relax matters to be more compatible with C++, we need
@@ -1025,10 +148,11 @@ static PyObject *missing_func(PyObject * /* self */ , PyObject *args)
     if (!PyLong_Check(value))
         Py_RETURN_NONE;
     auto *type = reinterpret_cast<PyTypeObject *>(klass);
-    auto *sbk_missing = PyDict_GetItem(type->tp_dict, _sbk_missing);
+    AutoDecRef tpDict(PepType_GetDict(type));
+    auto *sbk_missing = PyDict_GetItem(tpDict.object(), _sbk_missing);
     if (!sbk_missing) {
         sbk_missing = PyDict_New();
-        PyDict_SetItem(type->tp_dict, _sbk_missing, sbk_missing);
+        PyDict_SetItem(tpDict.object(), _sbk_missing, sbk_missing);
     }
     // See if the value is already in the dict.
     AutoDecRef val_str(PyObject_CallMethod(value, "__str__", nullptr));
@@ -1079,35 +203,99 @@ static PyObject *create_missing_func(PyObject *klass)
     static auto *const obType = reinterpret_cast<PyObject *>(type);
     static auto *const _missing = Shiboken::String::createStaticString("_missing_");
     static auto *const func = PyObject_GetAttr(obType, _missing);
-    static auto *const functools = PyImport_ImportModule("_functools");   // builtin
-    static auto *const _partial = Shiboken::String::createStaticString("partial");
-    static auto *const partial = PyObject_GetAttr(functools, _partial);
+    static auto *const partial = Pep_GetPartialFunction();
     return PyObject_CallFunctionObjArgs(partial, func, klass, nullptr);
 }
 //
 ////////////////////////////////////////////////////////////////////////
 
-PyTypeObject *morphLastEnumToPython()
+} // extern "C"
+
+namespace Shiboken::Enum {
+
+int enumOption{};
+
+bool check(PyObject *pyObj)
 {
-    /// The Python Enum internal structure is way too complicated.
-    /// It is much easier to generate Python code and execute it.
+    init_enum();
 
-    // Pick up the last generated Enum and convert it into a PyEnum
-    auto *enumType = lec.enumType;
-    // This is temporary; SbkEnumType will be removed, soon.
+    static PyTypeObject *meta = getPyEnumMeta();
+    return Py_TYPE(Py_TYPE(pyObj)) == reinterpret_cast<PyTypeObject *>(meta);
+}
 
-    // PYSIDE-1735: Decide dynamically if new or old enums will be used.
-    if (useOldEnum)
-        return enumType;
+PyObject *getEnumItemFromValue(PyTypeObject *enumType, EnumValueType itemValue)
+{
+    init_enum();
 
-    auto *setp = PepType_SETP(reinterpret_cast<SbkEnumType *>(enumType));
-    if (setp->replacementType) {
-        // For some (yet to fix) reason, initialization of the enums can happen twice.
-        // If that happens, use the existing new type to keep type checks correct.
-        return setp->replacementType;
+    auto *obEnumType = reinterpret_cast<PyObject *>(enumType);
+    AutoDecRef val2members(PyObject_GetAttrString(obEnumType, "_value2member_map_"));
+    if (val2members.isNull()) {
+        PyErr_Clear();
+        return nullptr;
     }
+    AutoDecRef ob_value(PyLong_FromLongLong(itemValue));
+    auto *result = PyDict_GetItem(val2members, ob_value);
+    Py_XINCREF(result);
+    return result;
+}
+
+PyObject *newItem(PyTypeObject *enumType, EnumValueType itemValue,
+                  const char *itemName)
+{
+    init_enum();
+
+    auto *obEnumType = reinterpret_cast<PyObject *>(enumType);
+    if (!itemName)
+        return PyObject_CallFunction(obEnumType, "L", itemValue);
+
+    static PyObject *const _member_map_ = String::createStaticString("_member_map_");
+    AutoDecRef tpDict(PepType_GetDict(enumType));
+    auto *member_map = PyDict_GetItem(tpDict.object(), _member_map_);
+    if (!(member_map && PyDict_Check(member_map)))
+        return nullptr;
+    auto *result = PyDict_GetItemString(member_map, itemName);
+    Py_XINCREF(result);
+    return result;
+}
+
+EnumValueType getValue(PyObject *enumItem)
+{
+    init_enum();
+
+    assert(Enum::check(enumItem));
+
+    AutoDecRef pyValue(PyObject_GetAttrString(enumItem, "value"));
+    return PyLong_AsLongLong(pyValue);
+}
+
+void setTypeConverter(PyTypeObject *type, SbkConverter *converter)
+{
+    auto *enumType = reinterpret_cast<SbkEnumType *>(type);
+    PepType_SETP(enumType)->converter = converter;
+}
+
+static PyTypeObject *createEnumForPython(PyObject *scopeOrModule,
+                                         const char *fullName,
+                                         PyObject *pyEnumItems)
+{
+    const char *colon = strchr(fullName, ':');
+    assert(colon);
+    int package_level = atoi(fullName);
+    const char *mod = colon + 1;
+
+    const char *qual = mod;
+    for (int idx = package_level; idx > 0; --idx) {
+        const char *dot = strchr(qual, '.');
+        if (!dot)
+            break;
+        qual = dot + 1;
+    }
+    int mlen = qual - mod - 1;
+    AutoDecRef module(Shiboken::String::fromCString(mod, mlen));
+    AutoDecRef qualname(Shiboken::String::fromCString(qual));
+    const char *dot = strrchr(qual, '.');
+    AutoDecRef name(Shiboken::String::fromCString(dot ? dot + 1 : qual));
 
-    auto *scopeOrModule = lec.scopeOrModule;
     static PyObject *enumName = String::createStaticString("IntEnum");
     if (PyType_Check(scopeOrModule)) {
         // For global objects, we have no good solution, yet where to put the int info.
@@ -1115,15 +303,11 @@ PyTypeObject *morphLastEnumToPython()
         auto *sotp = PepType_SOTP(type);
         if (!sotp->enumFlagsDict)
             initEnumFlagsDict(type);
-        enumName = PyDict_GetItem(sotp->enumTypeDict, String::fromCString(lec.name));
+        enumName = PyDict_GetItem(sotp->enumTypeDict, name);
     }
 
-    PyObject *key, *value;
-    Py_ssize_t pos = 0;
-    PyObject *values = PyDict_GetItem(enumType->tp_dict, PyName::values());
-    if (!values)
-        return nullptr;
-
+    SBK_UNUSED(getPyEnumMeta()); // enforce PyEnumModule creation
+    assert(PyEnumModule != nullptr);
     AutoDecRef PyEnumType(PyObject_GetAttr(PyEnumModule, enumName));
     assert(PyEnumType.object());
     bool isFlag = PyObject_IsSubclass(PyEnumType, PyFlag);
@@ -1136,24 +320,13 @@ PyTypeObject *morphLastEnumToPython()
         PyEnumType.reset(surrogate);
     }
 
-    // Walk the values dict and create a Python enum type.
-    AutoDecRef name(PyUnicode_FromString(lec.name));
-    AutoDecRef args(PyList_New(0));
+    // Walk the enumItemStrings and create a Python enum type.
     auto *pyName = name.object();
-    auto *pyArgs = args.object();
-    while (PyDict_Next(values, &pos, &key, &value)) {
-        auto *key_value = PyTuple_New(2);
-        PyTuple_SET_ITEM(key_value, 0, key);
-        Py_INCREF(key);
-        auto *obj = reinterpret_cast<SbkEnumObject *>(value);
-        auto *num = PyLong_FromLongLong(obj->ob_value);
-        PyTuple_SET_ITEM(key_value, 1, num);
-        PyList_Append(pyArgs, key_value);
-    }
+
     // We now create the new type. Since Python 3.11, we need to pass in
     // `boundary=KEEP` because the default STRICT crashes on us.
     // See  QDir.Filter.Drives | QDir.Filter.Files
-    AutoDecRef callArgs(Py_BuildValue("(OO)", pyName, pyArgs));
+    AutoDecRef callArgs(Py_BuildValue("(OO)", pyName, pyEnumItems));
     AutoDecRef callDict(PyDict_New());
     static PyObject *boundary = String::createStaticString("boundary");
     if (PyFlag_KEEP)
@@ -1172,40 +345,110 @@ PyTypeObject *morphLastEnumToPython()
     }
 
     auto *newType = reinterpret_cast<PyTypeObject *>(obNewType);
-    auto *obEnumType = reinterpret_cast<PyObject *>(enumType);
-    AutoDecRef qual_name(PyObject_GetAttr(obEnumType, PyMagicName::qualname()));
-    PyObject_SetAttr(obNewType, PyMagicName::qualname(), qual_name);
-    AutoDecRef module(PyObject_GetAttr(obEnumType, PyMagicName::module()));
+    PyObject_SetAttr(obNewType, PyMagicName::qualname(), qualname);
     PyObject_SetAttr(obNewType, PyMagicName::module(), module);
 
     // See if we should re-introduce shortcuts in the enclosing object.
     const bool useGlobalShortcut = (Enum::enumOption & Enum::ENOPT_GLOBAL_SHORTCUT) != 0;
     const bool useScopedShortcut = (Enum::enumOption & Enum::ENOPT_SCOPED_SHORTCUT) != 0;
     if (useGlobalShortcut || useScopedShortcut) {
+        // We have to use the iterator protokol because the values dict is a mappingproxy.
+        AutoDecRef values(PyObject_GetAttr(obNewType, PyMagicName::members()));
+        AutoDecRef mapIterator(PyObject_GetIter(values));
+        AutoDecRef mapKey{};
         bool isModule = PyModule_Check(scopeOrModule);
-        pos = 0;
-        while (PyDict_Next(values, &pos, &key, &value)) {
-            AutoDecRef entry(PyObject_GetAttr(obNewType, key));
-            if ((useGlobalShortcut && isModule) || (useScopedShortcut && !isModule))
-                if (PyObject_SetAttr(scopeOrModule, key, entry) < 0)
+        while ((mapKey.reset(PyIter_Next(mapIterator))), mapKey.object()) {
+            if ((useGlobalShortcut && isModule) || (useScopedShortcut && !isModule)) {
+                AutoDecRef value(PyObject_GetItem(values, mapKey));
+                if (PyObject_SetAttr(scopeOrModule, mapKey, value) < 0)
                     return nullptr;
+            }
         }
     }
 
-    // Protect against double initialization
-    setp->replacementType = newType;
-
-    // PYSIDE-1735: Old Python versions can't stand the early enum deallocation.
-    static bool old_python_version = is_old_version();
-    if (old_python_version)
-        Py_INCREF(obEnumType);
     return newType;
 }
 
-PyTypeObject *mapFlagsToSameEnum(PyTypeObject *FType, PyTypeObject *EType)
+template <typename IntT>
+static PyObject *toPyObject(IntT v)
 {
-    // this will be switchable...
-    return useOldEnum ? FType : EType;
+    if constexpr (sizeof(IntT) == 8) {
+        if constexpr (std::is_unsigned_v<IntT>)
+            return PyLong_FromUnsignedLongLong(v);
+        return PyLong_FromLongLong(v);
+    }
+    if constexpr (std::is_unsigned_v<IntT>)
+        return PyLong_FromUnsignedLong(v);
+    return PyLong_FromLong(v);
 }
 
-} // extern "C"
+template <typename IntT>
+static PyTypeObject *createPythonEnumHelper(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const IntT enumValues[])
+{
+    AutoDecRef args(PyList_New(0));
+    auto *pyEnumItems = args.object();
+    for (size_t idx = 0; enumItemStrings[idx] != nullptr; ++idx) {
+        const char *kv = enumItemStrings[idx];
+        auto *key = PyUnicode_FromString(kv);
+        auto *value = toPyObject(enumValues[idx]);
+        auto *key_value = PyTuple_New(2);
+        PyTuple_SET_ITEM(key_value, 0, key);
+        PyTuple_SET_ITEM(key_value, 1, value);
+        PyList_Append(pyEnumItems, key_value);
+    }
+    return createEnumForPython(module, fullName, pyEnumItems);
+}
+
+// Now we have to concretize these functions explicitly,
+// otherwise templates will not work across modules.
+
+PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const int64_t enumValues[])
+{
+    return createPythonEnumHelper(module, fullName, enumItemStrings, enumValues);
+}
+
+PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const uint64_t enumValues[])
+{
+    return createPythonEnumHelper(module, fullName, enumItemStrings, enumValues);
+}
+
+PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const int32_t enumValues[])
+{
+    return createPythonEnumHelper(module, fullName, enumItemStrings, enumValues);
+}
+
+PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const uint32_t enumValues[])
+{
+    return createPythonEnumHelper(module, fullName, enumItemStrings, enumValues);
+}
+
+PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const int16_t enumValues[])
+{
+    return createPythonEnumHelper(module, fullName, enumItemStrings, enumValues);
+}
+
+PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const uint16_t enumValues[])
+{
+    return createPythonEnumHelper(module, fullName, enumItemStrings, enumValues);
+}
+
+PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const int8_t enumValues[])
+{
+    return createPythonEnumHelper(module, fullName, enumItemStrings, enumValues);
+}
+
+PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const uint8_t enumValues[])
+{
+    return createPythonEnumHelper(module, fullName, enumItemStrings, enumValues);
+}
+
+} // namespace Shiboken::Enum
diff --git a/sources/shiboken6/libshiboken/sbkenum.h b/sources/shiboken6/libshiboken/sbkenum.h
index a39519189..e19ca4b4c 100644
--- a/sources/shiboken6/libshiboken/sbkenum.h
+++ b/sources/shiboken6/libshiboken/sbkenum.h
@@ -15,81 +15,88 @@ LIBSHIBOKEN_API bool PyEnumMeta_Check(PyObject *ob);
 /// exposed for the signature module
 LIBSHIBOKEN_API void init_enum();
 
-extern LIBSHIBOKEN_API PyTypeObject *SbkEnumType_TypeF(void);
 struct SbkConverter;
 struct SbkEnumType;
-struct SbkEnumTypePrivate;
 
-} // extern "C"
-
-namespace Shiboken
+struct SbkEnumTypePrivate
 {
+    SbkConverter *converter;
+};
+
+/// PYSIDE-1735: Pass on the Python enum/flag information.
+LIBSHIBOKEN_API void initEnumFlagsDict(PyTypeObject *type);
+
+/// PYSIDE-1735: Make sure that we can import the Python enum implementation.
+LIBSHIBOKEN_API PyTypeObject *getPyEnumMeta();
+/// PYSIDE-1735: Helper function supporting QEnum
+LIBSHIBOKEN_API int enumIsFlag(PyObject *ob_enum);
 
-inline bool isShibokenEnum(PyObject *pyObj)
-{
-    return Py_TYPE(Py_TYPE(pyObj)) == SbkEnumType_TypeF();
 }
 
-namespace Enum
+namespace Shiboken::Enum {
+
+enum : int {
+    ENOPT_OLD_ENUM        = 0x00,   // PySide 6.6: no longer supported
+    ENOPT_NEW_ENUM        = 0x01,
+    ENOPT_INHERIT_INT     = 0x02,
+    ENOPT_GLOBAL_SHORTCUT = 0x04,
+    ENOPT_SCOPED_SHORTCUT = 0x08,
+    ENOPT_NO_FAKESHORTCUT = 0x10,
+    ENOPT_NO_FAKERENAMES  = 0x20,
+    ENOPT_NO_ZERODEFAULT  = 0x40,
+    ENOPT_NO_MISSING      = 0x80,
+};
+
+LIBSHIBOKEN_API extern int enumOption;
+
+using EnumValueType = long long;
+
+LIBSHIBOKEN_API bool check(PyObject *obj);
+
+LIBSHIBOKEN_API PyObject *newItem(PyTypeObject *enumType, EnumValueType itemValue,
+                                  const char *itemName = nullptr);
+
+LIBSHIBOKEN_API EnumValueType getValue(PyObject *enumItem);
+LIBSHIBOKEN_API PyObject *getEnumItemFromValue(PyTypeObject *enumType,
+                                               EnumValueType itemValue);
+
+/// Sets the enum/flag's type converter.
+LIBSHIBOKEN_API void setTypeConverter(PyTypeObject *type, SbkConverter *converter);
+
+/// Creating Python enums for different types.
+LIBSHIBOKEN_API PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const int64_t enumValues[]);
+
+LIBSHIBOKEN_API PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const uint64_t enumValues[]);
+
+LIBSHIBOKEN_API PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const int32_t enumValues[]);
+
+LIBSHIBOKEN_API PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const uint32_t enumValues[]);
+
+LIBSHIBOKEN_API PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const int16_t enumValues[]);
+
+LIBSHIBOKEN_API PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const uint16_t enumValues[]);
+
+LIBSHIBOKEN_API PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const int8_t enumValues[]);
+
+LIBSHIBOKEN_API PyTypeObject *createPythonEnum(PyObject *module,
+    const char *fullName, const char *enumItemStrings[], const uint8_t enumValues[]);
+
+/// This template removes duplication by inlining necessary type casts.
+template <typename IntT>
+inline PyTypeObject *createPythonEnum(PyTypeObject *scope,
+    const char *fullName, const char *enumItemStrings[], const IntT enumValues[])
 {
-    using EnumValueType = long long;
-
-    LIBSHIBOKEN_API bool check(PyObject *obj);
-    /**
-     *  Creates a new enum type (and its flags type, if any is given)
-     *  and registers it to Python and adds it to \p module.
-     *  \param module       Module to where the new enum type will be added.
-     *  \param name         Name of the enum.
-     *  \param fullName     Name of the enum that includes all scope information (e.g.: "module.Enum").
-     *  \param cppName      Full qualified C++ name of the enum.
-     *  \param flagsType    Optional Python type for the flags associated with the enum.
-     *  \return The new enum type or NULL if it fails.
-     */
-    LIBSHIBOKEN_API PyTypeObject *createGlobalEnum(PyObject *module,
-                                                   const char *name,
-                                                   const char *fullName,
-                                                   const char *cppName,
-                                                   PyTypeObject *flagsType = nullptr);
-    /// This function does the same as createGlobalEnum, but adds the enum to a Shiboken type or namespace.
-    LIBSHIBOKEN_API PyTypeObject *createScopedEnum(PyTypeObject *scope,
-                                                   const char *name,
-                                                   const char *fullName,
-                                                   const char *cppName,
-                                                   PyTypeObject *flagsType = nullptr);
-
-    /**
-     *  Creates a new enum item for a given enum type and adds it to \p module.
-     *  \param enumType  Enum type to where the new enum item will be added.
-     *  \param module    Module to where the enum type of the new enum item belongs.
-     *  \param itemName  Name of the enum item.
-     *  \param itemValue Numerical value of the enum item.
-     *  \return true if everything goes fine, false if it fails.
-     */
-    LIBSHIBOKEN_API bool createGlobalEnumItem(PyTypeObject *enumType, PyObject *module,
-                                              const char *itemName,
-                                              EnumValueType itemValue);
-    /// This function does the same as createGlobalEnumItem, but adds the enum to a Shiboken type or namespace.
-    LIBSHIBOKEN_API bool createScopedEnumItem(PyTypeObject *enumType, PyTypeObject *scope,
-                                              const char *itemName, EnumValueType itemValue);
-
-    LIBSHIBOKEN_API PyObject *newItem(PyTypeObject *enumType, EnumValueType itemValue,
-                                      const char *itemName = nullptr);
-
-    LIBSHIBOKEN_API PyTypeObject *newTypeWithName(const char *name, const char *cppName,
-                                                  PyTypeObject *numbers_fromFlag=nullptr);
-    LIBSHIBOKEN_API const char *getCppName(PyTypeObject *type);
-    LIBSHIBOKEN_API PyObject *getCppNameNew(PyTypeObject *type);
-
-    LIBSHIBOKEN_API EnumValueType getValue(PyObject *enumItem);
-    LIBSHIBOKEN_API PyObject *getEnumItemFromValue(PyTypeObject *enumType,
-                                                   EnumValueType itemValue);
-
-    /// Sets the enum/flag's type converter.
-    LIBSHIBOKEN_API void setTypeConverter(PyTypeObject *type, SbkConverter *converter, bool isFlag);
-
-    LIBSHIBOKEN_API PyObject *unpickleEnum(PyObject *, PyObject *);
+    auto *obScope = reinterpret_cast<PyObject *>(scope);
+    return createPythonEnum(obScope, fullName, enumItemStrings, enumValues);
 }
 
-} // namespace Shiboken
+} // namespace Shiboken::Enum
 
 #endif // SKB_PYENUM_H
diff --git a/sources/shiboken6/libshiboken/sbkenum_p.h b/sources/shiboken6/libshiboken/sbkenum_p.h
deleted file mode 100644
index d8477b4b3..000000000
--- a/sources/shiboken6/libshiboken/sbkenum_p.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// 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 SBKENUM_P_H
-#define SBKENUM_P_H
-
-#include "sbkpython.h"
-#include "shibokenmacros.h"
-
-struct SbkEnumTypePrivate
-{
-    SbkConverter *converter;
-    const char *cppName;
-    PyTypeObject *replacementType;
-};
-
-extern "C" {
-
-/// PYSIDE-1735: Pass on the Python enum/flag information.
-LIBSHIBOKEN_API void initEnumFlagsDict(PyTypeObject *type);
-
-/// PYSIDE-1735: Patching the Enum / Flags implementation. Remove in 6.4
-LIBSHIBOKEN_API PyTypeObject *morphLastEnumToPython();
-LIBSHIBOKEN_API PyTypeObject *mapFlagsToSameEnum(PyTypeObject *FType, PyTypeObject *EType);
-
-/// PYSIDE-1735: Make sure that we can import the Python enum implementation.
-LIBSHIBOKEN_API PyTypeObject *getPyEnumMeta();
-/// PYSIDE-1735: Helper function supporting QEnum
-LIBSHIBOKEN_API int enumIsFlag(PyObject *ob_enum);
-/// PYSIDE-1735: Helper function to ask what enum we are using
-LIBSHIBOKEN_API bool usingNewEnum();
-
-}
-
-namespace Shiboken { namespace Enum {
-
-enum : int {
-    ENOPT_OLD_ENUM        = 0x00,
-    ENOPT_NEW_ENUM        = 0x01,
-    ENOPT_INHERIT_INT     = 0x02,
-    ENOPT_GLOBAL_SHORTCUT = 0x04,
-    ENOPT_SCOPED_SHORTCUT = 0x08,
-    ENOPT_NO_FAKESHORTCUT = 0x10,
-    ENOPT_NO_FAKERENAMES  = 0x20,
-    ENOPT_NO_ZERODEFAULT  = 0x40,
-    ENOPT_NO_MISSING      = 0x80,
-};
-
-LIBSHIBOKEN_API extern int enumOption;
-
-}}
-
-#endif // SBKENUM_P_H
diff --git a/sources/shiboken6/libshiboken/sbkerrors.cpp b/sources/shiboken6/libshiboken/sbkerrors.cpp
index c8f8a989f..84c080f8d 100644
--- a/sources/shiboken6/libshiboken/sbkerrors.cpp
+++ b/sources/shiboken6/libshiboken/sbkerrors.cpp
@@ -2,10 +2,42 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #include "sbkerrors.h"
+#include "sbkstring.h"
 #include "helper.h"
+#include "gilstate.h"
+
+#include <cstdio>
+#include <string>
+
+using namespace std::literals::string_literals;
 
 namespace Shiboken
 {
+
+// PYSIDE-2335: Track down if we can reach a Python error handler.
+//              _pythonContextStack has always the current state of handler status
+//              in its lowest bit.
+//              Blocking calls like exec or run need to use `setBlocking`.
+static thread_local std::size_t _pythonContextStack{};
+
+PythonContextMarker::PythonContextMarker()
+{
+    // Shift history up and set lowest bit.
+    _pythonContextStack = (_pythonContextStack * 2) + 1;
+}
+
+PythonContextMarker::~PythonContextMarker()
+{
+    // Shift history down.
+    _pythonContextStack /= 2;
+}
+
+void PythonContextMarker::setBlocking()
+{
+    // Clear lowest bit.
+    _pythonContextStack = _pythonContextStack / 2 * 2;
+}
+
 namespace Errors
 {
 
@@ -66,6 +98,74 @@ void setWrongContainerType()
     PyErr_SetString(PyExc_TypeError, "Wrong type passed to container conversion.");
 }
 
+// Prepend something to an exception message provided it is a single string
+// argument.
+static bool prependToExceptionMessage(PyObject *exc, const char *context)
+{
+    Shiboken::AutoDecRef args(PepException_GetArgs(exc));
+    if (args.isNull() || PyTuple_Check(args.object()) == 0 || PyTuple_Size(args) != 1)
+        return false;
+    auto *oldMessage = PyTuple_GetItem(args, 0);
+    if (oldMessage == nullptr || PyUnicode_CheckExact(oldMessage) == 0)
+        return false;
+    auto *newMessage = PyUnicode_FromFormat("%s%U", context, oldMessage);
+    PepException_SetArgs(exc, PyTuple_Pack(1, newMessage));
+    return true;
+}
+
+struct ErrorStore {
+    PyObject *type;
+    PyObject *exc;
+    PyObject *traceback;
+};
+
+static thread_local ErrorStore savedError{};
+
+static bool hasPythonContext()
+{
+    return _pythonContextStack & 1;
+}
+
+void storeErrorOrPrint()
+{
+    // This error happened in a function with no way to return an error state.
+    // Therefore, we handle the error when we are error checking, anyway.
+    // But we do that only when we know that an error handler can pick it up.
+    if (hasPythonContext())
+        PyErr_Fetch(&savedError.type, &savedError.exc, &savedError.traceback);
+    else
+        PyErr_Print();
+}
+
+// Like storeErrorOrPrint() with additional context info that is prepended
+// to the exception message or printed.
+static void storeErrorOrPrintWithContext(const char *context)
+{
+    if (hasPythonContext()) {
+        PyErr_Fetch(&savedError.type, &savedError.exc, &savedError.traceback);
+        prependToExceptionMessage(savedError.exc, context);
+    } else {
+        std::fputs(context, stderr);
+        PyErr_Print();
+    }
+}
+
+void storePythonOverrideErrorOrPrint(const char *className, const char *funcName)
+{
+    const std::string context = "Error calling Python override of "s
+                                + className + "::"s + funcName + "(): "s;
+    storeErrorOrPrintWithContext(context.c_str());
+}
+
+PyObject *occurred()
+{
+    if (savedError.type) {
+        PyErr_Restore(savedError.type, savedError.exc, savedError.traceback);
+        savedError.type = nullptr;
+    }
+    return PyErr_Occurred();
+}
+
 } // namespace Errors
 
 namespace Warnings
diff --git a/sources/shiboken6/libshiboken/sbkerrors.h b/sources/shiboken6/libshiboken/sbkerrors.h
index d894d8e7a..18ce701e7 100644
--- a/sources/shiboken6/libshiboken/sbkerrors.h
+++ b/sources/shiboken6/libshiboken/sbkerrors.h
@@ -7,8 +7,31 @@
 #include "sbkpython.h"
 #include "shibokenmacros.h"
 
+/// Craving for C++20 and std::source_location::current()
+#if defined(_MSC_VER)
+#  define SBK_FUNC_INFO     __FUNCSIG__
+#elif defined(__GNUC__)
+#  define SBK_FUNC_INFO     __PRETTY_FUNCTION__
+#else
+#  define SBK_FUNC_INFO     __FUNCTION__
+#endif
+
 namespace Shiboken
 {
+
+struct LIBSHIBOKEN_API PythonContextMarker
+{
+public:
+    PythonContextMarker(const PythonContextMarker &) = delete;
+    PythonContextMarker(PythonContextMarker &&) = delete;
+    PythonContextMarker &operator=(const PythonContextMarker &) = delete;
+    PythonContextMarker &operator=(PythonContextMarker &&) = delete;
+
+    explicit PythonContextMarker();
+    ~PythonContextMarker();
+    void setBlocking();
+};
+
 namespace Errors
 {
 
@@ -23,6 +46,20 @@ LIBSHIBOKEN_API void setSequenceTypeError(const char *expectedType);
 LIBSHIBOKEN_API void setSetterTypeError(const char *name, const char *expectedType);
 LIBSHIBOKEN_API void setWrongContainerType();
 
+/// Report an error ASAP: Instead of printing, store for later re-raise.
+/// This replaces `PyErr_Print`, which cannot report errors as exception.
+/// To be used in contexts where raising errors is impossible.
+LIBSHIBOKEN_API void storeErrorOrPrint();
+
+/// Call storeErrorOrPrint() and print the context to report
+/// errors when calling Python overrides of virtual functions.
+LIBSHIBOKEN_API void storePythonOverrideErrorOrPrint(const char *className, const char *funcName);
+
+/// Handle an error as in PyErr_Occurred(), but also check for errors which
+/// were captured by `storeErrorOrPrint`.
+/// To be used in normal error checks.
+LIBSHIBOKEN_API PyObject *occurred();
+
 } // namespace Errors
 
 namespace Warnings
diff --git a/sources/shiboken6/libshiboken/sbkfeature_base.cpp b/sources/shiboken6/libshiboken/sbkfeature_base.cpp
index 1d1399ae7..f31b8f4f7 100644
--- a/sources/shiboken6/libshiboken/sbkfeature_base.cpp
+++ b/sources/shiboken6/libshiboken/sbkfeature_base.cpp
@@ -4,7 +4,8 @@
 #include "basewrapper.h"
 #include "basewrapper_p.h"
 #include "autodecref.h"
-#include "sbkenum_p.h"
+#include "pep384ext.h"
+#include "sbkenum.h"
 #include "sbkstring.h"
 #include "sbkstaticstrings.h"
 #include "sbkstaticstrings_p.h"
@@ -12,6 +13,8 @@
 #include "sbkfeature_base.h"
 #include "gilstate.h"
 
+#include <cctype>
+
 using namespace Shiboken;
 
 extern "C"
@@ -19,65 +22,39 @@ extern "C"
 
 ////////////////////////////////////////////////////////////////////////////
 //
-// getFeatureSelectId
-//
-// This function is needed here already for signature handling.
-// Maybe the same function from feature_select.cpp will be replaced.
+// Minimal __feature__ support in Shiboken
 //
-
-static PyObject *cached_globals{};
-static PyObject *last_select_id{};
-
-PyObject *getFeatureSelectId()
-{
-    static PyObject *undef = PyLong_FromLong(-1);
-    static PyObject *feature_dict = GetFeatureDict();
-    // these things are all borrowed
-    PyObject *globals = PyEval_GetGlobals();
-    if (globals == nullptr
-        || globals == cached_globals)
-        return last_select_id;
-
-    PyObject *modname = PyDict_GetItem(globals, PyMagicName::name());
-    if (modname == nullptr)
-        return last_select_id;
-
-    PyObject *select_id = PyDict_GetItem(feature_dict, modname);
-    if (select_id == nullptr
-        || !PyLong_Check(select_id)  // int/long cheating
-        || select_id == undef)
-        return last_select_id;
-
-    cached_globals = globals;
-    last_select_id = select_id;
-    assert(PyLong_AsSsize_t(select_id) >= 0);
-    return select_id;
-}
-
 int currentSelectId(PyTypeObject *type)
 {
-    int sel = SbkObjectType_GetReserved(type);
-    // This could theoretically be -1 if used too early.
-    assert(sel >= 0);
+    AutoDecRef tpDict(PepType_GetDict(type));
+    PyObject *PyId = PyObject_GetAttr(tpDict.object(), PyName::select_id());
+    if (PyId == nullptr) {
+        PyErr_Clear();
+        return 0x00;
+    }
+    int sel = PyLong_AsLong(PyId);
+    Py_DECREF(PyId);
     return sel;
 }
 
-void initFeatureShibokenPart()
+static SelectableFeatureHook SelectFeatureSet = nullptr;
+static SelectableFeatureCallback featureCb = nullptr;
+
+void setSelectableFeatureCallback(SelectableFeatureCallback func)
 {
-    static PyObject *no_sel = PyLong_FromLong(0);
-    last_select_id = no_sel;
-    // Reset the cache. This is called at any "from __feature__ import".
-    cached_globals = nullptr;
+    featureCb = func;
 }
 
-static SelectableFeatureHook SelectFeatureSet = nullptr;
-
 SelectableFeatureHook initSelectableFeature(SelectableFeatureHook func)
 {
     auto ret = SelectFeatureSet;
     SelectFeatureSet = func;
+    if (featureCb)
+        featureCb(SelectFeatureSet != nullptr);
     return ret;
 }
+//
+////////////////////////////////////////////////////////////////////////////
 
 // This useful function is for debugging
 void disassembleFrame(const char *marker)
@@ -88,47 +65,62 @@ void disassembleFrame(const char *marker)
     static PyObject *dismodule = PyImport_ImportModule("dis");
     static PyObject *disco = PyObject_GetAttrString(dismodule, "disco");
     static PyObject *const _f_lasti = Shiboken::String::createStaticString("f_lasti");
+    static PyObject *const _f_lineno = Shiboken::String::createStaticString("f_lineno");
     static PyObject *const _f_code = Shiboken::String::createStaticString("f_code");
+    static PyObject *const _co_filename = Shiboken::String::createStaticString("co_filename");
+    AutoDecRef ignore{};
     auto *frame = reinterpret_cast<PyObject *>(PyEval_GetFrame());
-    AutoDecRef f_lasti(PyObject_GetAttr(frame, _f_lasti));
-    AutoDecRef f_code(PyObject_GetAttr(frame, _f_code));
-    fprintf(stdout, "\n%s BEGIN\n", marker);
-    PyObject_CallFunctionObjArgs(disco, f_code.object(), f_lasti.object(), nullptr);
-    fprintf(stdout, "%s END\n\n", marker);
-    static PyObject *sysmodule = PyImport_ImportModule("sys");
-    static PyObject *stdout_file = PyObject_GetAttrString(sysmodule, "stdout");
-    PyObject_CallMethod(stdout_file, "flush", nullptr);
+    if (frame == nullptr) {
+        fprintf(stdout, "\n%s BEGIN no frame END\n\n", marker);
+    } else {
+        AutoDecRef f_lasti(PyObject_GetAttr(frame, _f_lasti));
+        AutoDecRef f_lineno(PyObject_GetAttr(frame, _f_lineno));
+        AutoDecRef f_code(PyObject_GetAttr(frame, _f_code));
+        AutoDecRef co_filename(PyObject_GetAttr(f_code, _co_filename));
+        long line = PyLong_AsLong(f_lineno);
+        const char *fname = String::toCString(co_filename);
+        fprintf(stdout, "\n%s BEGIN line=%ld %s\n", marker, line, fname);
+        ignore.reset(PyObject_CallFunctionObjArgs(disco, f_code.object(), f_lasti.object(), nullptr));
+        fprintf(stdout, "%s END line=%ld %s\n\n", marker, line, fname);
+    }
+#if PY_VERSION_HEX >= 0x030C0000 && !Py_LIMITED_API
+    if (error_type)
+        PyErr_DisplayException(error_value);
+#endif
+    static PyObject *stdout_file = PySys_GetObject("stdout");
+    ignore.reset(PyObject_CallMethod(stdout_file, "flush", nullptr));
     PyErr_Restore(error_type, error_value, error_traceback);
 }
 
+// python 3.12
+static int const CALL = 171;
 // Python 3.11
 static int const PRECALL = 166;
-// we have "big instructins" with gaps after them
-static int const LOAD_ATTR_GAP = 4 * 2;
-static int const LOAD_METHOD_GAP = 10 * 2;
+// we have "big instructions" with gaps after them
+static int const LOAD_METHOD_GAP_311 = 10 * 2;
+static int const LOAD_ATTR_GAP_311 = 4 * 2;
+static int const LOAD_ATTR_GAP = 9 * 2;
 // Python 3.7 - 3.10
 static int const LOAD_METHOD = 160;
 static int const CALL_METHOD = 161;
 // Python 3.6
 static int const CALL_FUNCTION = 131;
 static int const LOAD_ATTR = 106;
-
-static int _getVersion()
-{
-    static PyObject *const sysmodule = PyImport_AddModule("sys");
-    static PyObject *const version = PyObject_GetAttrString(sysmodule, "version_info");
-    static PyObject *const major = PyTuple_GetItem(version, 0);
-    static PyObject *const minor = PyTuple_GetItem(version, 1);
-    static auto number = PyLong_AsLong(major) * 1000 + PyLong_AsLong(minor);
-    return number;
-}
+// NoGil (how long will this exist in this form?)
+static int const LOAD_METHOD_NOGIL = 55;
+static int const CALL_METHOD_NOGIL = 72;
 
 static bool currentOpcode_Is_CallMethNoArgs()
 {
+    // PYSIDE-2221: Special case for the NoGil version:
+    //              Find out if we have such a version.
+    //              We could also ask the variable `Py_NOGIL`.
+    static PyObject *flags = PySys_GetObject("flags");
+    static bool isNoGil = PyObject_HasAttrString(flags, "nogil");
     // We look into the currently active operation if we are going to call
     // a method with zero arguments.
     auto *frame = PyEval_GetFrame();
-#if PY_VERSION_HEX >= 0x03090000 && !Py_LIMITED_API && !defined(PYPY_VERSION)
+#if !Py_LIMITED_API && !defined(PYPY_VERSION)
     auto *f_code = PyFrame_GetCode(frame);
 #else
     static PyObject *const _f_code = Shiboken::String::createStaticString("f_code");
@@ -149,20 +141,37 @@ static bool currentOpcode_Is_CallMethNoArgs()
     char *co_code{};
     PyBytes_AsStringAndSize(dec_co_code, &co_code, &code_len);
     uint8_t opcode1 = co_code[f_lasti];
+    if (isNoGil) {
+        uint8_t opcode2 = co_code[f_lasti + 4];
+        uint8_t oparg2 = co_code[f_lasti + 6];
+        return opcode1 == LOAD_METHOD_NOGIL && opcode2 == CALL_METHOD_NOGIL && oparg2 == 1;
+    }
     uint8_t opcode2 = co_code[f_lasti + 2];
     uint8_t oparg2 = co_code[f_lasti + 3];
-    static auto number = _getVersion();
-    if (number < 3007)
-        return opcode1 == LOAD_ATTR && opcode2 == CALL_FUNCTION && oparg2 == 0;
-    if (number < 3011)
+    static auto number = _PepRuntimeVersion();
+    if (number < 0x030B00)
         return opcode1 == LOAD_METHOD && opcode2 == CALL_METHOD && oparg2 == 0;
 
-    // With Python 3.11, the opcodes get bigger and change a bit.
+    if (number < 0x030C00) {
+        // With Python 3.11, the opcodes get bigger and change a bit.
+        // Note: The new adaptive opcodes are elegantly hidden and we
+        //       don't need to take care of them.
+        if (opcode1 == LOAD_METHOD)
+            f_lasti += LOAD_METHOD_GAP_311;
+        else if (opcode1 == LOAD_ATTR)
+            f_lasti += LOAD_ATTR_GAP_311;
+        else
+            return false;
+
+        opcode2 = co_code[f_lasti + 2];
+        oparg2 = co_code[f_lasti + 3];
+
+        return opcode2 == PRECALL && oparg2 == 0;
+    }
+    // With Python 3.12, the opcodes get again bigger and change a bit.
     // Note: The new adaptive opcodes are elegantly hidden and we
     //       don't need to take care of them.
-    if (opcode1 == LOAD_METHOD)
-        f_lasti += LOAD_METHOD_GAP;
-    else if (opcode1 == LOAD_ATTR)
+    if (opcode1 == LOAD_ATTR)
         f_lasti += LOAD_ATTR_GAP;
     else
         return false;
@@ -170,7 +179,7 @@ static bool currentOpcode_Is_CallMethNoArgs()
     opcode2 = co_code[f_lasti + 2];
     oparg2 = co_code[f_lasti + 3];
 
-    return opcode2 == PRECALL && oparg2 == 0;
+    return opcode2 == CALL && oparg2 == 0;
 }
 
 void initEnumFlagsDict(PyTypeObject *type)
@@ -201,12 +210,107 @@ void initEnumFlagsDict(PyTypeObject *type)
 
 static PyObject *replaceNoArgWithZero(PyObject *callable)
 {
-    static auto *functools = PyImport_ImportModule("_functools");   // builtin
-    static auto *partial = PyObject_GetAttrString(functools, "partial");
+    static auto *partial = Pep_GetPartialFunction();
     static auto *zero = PyLong_FromLong(0);
     return PyObject_CallFunctionObjArgs(partial, callable, zero, nullptr);
 }
 
+static PyObject *lookupUnqualifiedOrOldEnum(PyTypeObject *type, PyObject *name)
+{
+    // MRO has been observed to be 0 in case of errors with QML decorators
+    if (type == nullptr || type->tp_mro == nullptr)
+        return nullptr;
+    // Quick Check: Avoid "__..", "_slots", etc.
+    if (std::isalpha(Shiboken::String::toCString(name)[0]) == 0)
+        return nullptr;
+    static PyTypeObject *const EnumMeta = getPyEnumMeta();
+    static PyObject *const _member_map_ = String::createStaticString("_member_map_");
+    // This is similar to `find_name_in_mro`, but instead of looking directly into
+    // tp_dict, we also search for the attribute in local classes of that dict (Part 2).
+    PyObject *mro = type->tp_mro;
+    PyObject *result{};
+    assert(PyTuple_Check(mro));
+    Py_ssize_t idx, n = PyTuple_GET_SIZE(mro);
+    for (idx = 0; idx < n; ++idx) {
+        auto *base = PyTuple_GET_ITEM(mro, idx);
+        auto *type_base = reinterpret_cast<PyTypeObject *>(base);
+        if (!SbkObjectType_Check(type_base))
+            continue;
+        auto sotp = PepType_SOTP(type_base);
+        // The EnumFlagInfo structure tells us if there are Enums at all.
+        const char **enumFlagInfo = sotp->enumFlagInfo;
+        if (!(enumFlagInfo))
+            continue;
+        if (!sotp->enumFlagsDict)
+            initEnumFlagsDict(type_base);
+        bool useFakeRenames = !(Enum::enumOption & Enum::ENOPT_NO_FAKERENAMES);
+        if (useFakeRenames) {
+            auto *rename = PyDict_GetItem(sotp->enumFlagsDict, name);
+            if (rename) {
+                /*
+                 * Part 1: Look into the enumFlagsDict if we have an old flags name.
+                 * -------------------------------------------------------------
+                 * We need to replace the parameterless
+
+                    QtCore.Qt.Alignment()
+
+                 * by the one-parameter call
+
+                    QtCore.Qt.AlignmentFlag(0)
+
+                 * That means: We need to bind the zero as default into a wrapper and
+                 * return that to be called.
+                 *
+                 * Addendum:
+                 * ---------
+                 * We first need to look into the current opcode of the bytecode to find
+                 * out if we have a call like above or just a type lookup.
+                 */
+                AutoDecRef tpDict(PepType_GetDict(type_base));
+                auto *flagType = PyDict_GetItem(tpDict.object(), rename);
+                if (currentOpcode_Is_CallMethNoArgs())
+                    return replaceNoArgWithZero(flagType);
+                Py_INCREF(flagType);
+                return flagType;
+            }
+        }
+        bool useFakeShortcuts = !(Enum::enumOption & Enum::ENOPT_NO_FAKESHORTCUT);
+        if (useFakeShortcuts) {
+            AutoDecRef tpDict(PepType_GetDict(type_base));
+            auto *dict = tpDict.object();
+            PyObject *key, *value;
+            Py_ssize_t pos = 0;
+            while (PyDict_Next(dict, &pos, &key, &value)) {
+                /*
+                 * Part 2: Check for a duplication into outer scope.
+                 * -------------------------------------------------
+                 * We need to replace the shortcut
+
+                    QtCore.Qt.AlignLeft
+
+                 * by the correct call
+
+                    QtCore.Qt.AlignmentFlag.AlignLeft
+
+                 * That means: We need to search all Enums of the class.
+                 */
+                if (Py_TYPE(value) == EnumMeta) {
+                    auto *valtype = reinterpret_cast<PyTypeObject *>(value);
+                    AutoDecRef valtypeDict(PepType_GetDict(valtype));
+                    auto *member_map = PyDict_GetItem(valtypeDict.object(), _member_map_);
+                    if (member_map && PyDict_Check(member_map)) {
+                        result = PyDict_GetItem(member_map, name);
+                        Py_XINCREF(result);
+                        if (result)
+                            return result;
+                    }
+                }
+            }
+        }
+    }
+    return nullptr;
+}
+
 PyObject *mangled_type_getattro(PyTypeObject *type, PyObject *name)
 {
     /*
@@ -215,21 +319,20 @@ PyObject *mangled_type_getattro(PyTypeObject *type, PyObject *name)
      * with the complex `tp_getattro` of `QObject` and other instances.
      * What we change here is the meta class of `QObject`.
      */
-    static getattrofunc const type_getattro = PyType_Type.tp_getattro;
+    static getattrofunc const type_getattro = PepExt_Type_GetGetAttroSlot(&PyType_Type);
     static PyObject *const ignAttr1 = PyName::qtStaticMetaObject();
     static PyObject *const ignAttr2 = PyMagicName::get();
     static PyTypeObject *const EnumMeta = getPyEnumMeta();
-    static PyObject *const _member_map_ = String::createStaticString("_member_map_");
 
     if (SelectFeatureSet != nullptr)
-        type->tp_dict = SelectFeatureSet(type);
+        SelectFeatureSet(type);
     auto *ret = type_getattro(reinterpret_cast<PyObject *>(type), name);
 
     // PYSIDE-1735: Be forgiving with strict enums and fetch the enum, silently.
     //              The PYI files now look correct, but the old duplication is
     //              emulated here. This should be removed in Qt 7, see `parser.py`.
     //
-    // FIXME PYSIDE7 should remove this forgivingness:
+    // FIXME PYSIDE7 should remove this forgiveness:
     //
     //      The duplication of enum values into the enclosing scope, allowing to write
     //      Qt.AlignLeft instead of Qt.Alignment.AlignLeft, is still implemented but
@@ -246,88 +349,16 @@ PyObject *mangled_type_getattro(PyTypeObject *type, PyObject *name)
     }
 
     if (!ret && name != ignAttr1 && name != ignAttr2) {
-        PyObject *error_type, *error_value, *error_traceback;
+        PyObject *error_type{}, *error_value{}, *error_traceback{};
         PyErr_Fetch(&error_type, &error_value, &error_traceback);
-
-        // This is similar to `find_name_in_mro`, but instead of looking directly into
-        // tp_dict, we also search for the attribute in local classes of that dict (Part 2).
-        PyObject *mro = type->tp_mro;
-        assert(PyTuple_Check(mro));
-        size_t idx, n = PyTuple_GET_SIZE(mro);
-        for (idx = 0; idx < n; ++idx) {
-            auto *base = PyTuple_GET_ITEM(mro, idx);
-            auto *type_base = reinterpret_cast<PyTypeObject *>(base);
-            auto sotp = PepType_SOTP(type_base);
-            // The EnumFlagInfo structure tells us if there are Enums at all.
-            const char **enumFlagInfo = sotp->enumFlagInfo;
-            if (!(enumFlagInfo))
-                continue;
-            if (!sotp->enumFlagsDict)
-                initEnumFlagsDict(type_base);
-            bool useFakeRenames = !(Enum::enumOption & Enum::ENOPT_NO_FAKERENAMES);
-            if (useFakeRenames) {
-                auto *rename = PyDict_GetItem(sotp->enumFlagsDict, name);
-                if (rename) {
-                    /*
-                     * Part 1: Look into the enumFlagsDict if we have an old flags name.
-                     * -------------------------------------------------------------
-                     * We need to replace the parameterless
-
-                        QtCore.Qt.Alignment()
-
-                     * by the one-parameter call
-
-                        QtCore.Qt.AlignmentFlag(0)
-
-                     * That means: We need to bind the zero as default into a wrapper and
-                     * return that to be called.
-                     *
-                     * Addendum:
-                     * ---------
-                     * We first need to look into the current opcode of the bytecode to find
-                     * out if we have a call like above or just a type lookup.
-                     */
-                    auto *flagType = PyDict_GetItem(type_base->tp_dict, rename);
-                    if (currentOpcode_Is_CallMethNoArgs())
-                        return replaceNoArgWithZero(flagType);
-                    Py_INCREF(flagType);
-                    return flagType;
-                }
-            }
-            bool useFakeShortcuts = !(Enum::enumOption & Enum::ENOPT_NO_FAKESHORTCUT);
-            if (useFakeShortcuts) {
-                auto *dict = type_base->tp_dict;
-                PyObject *key, *value;
-                Py_ssize_t pos = 0;
-                while (PyDict_Next(dict, &pos, &key, &value)) {
-                    /*
-                     * Part 2: Check for a duplication into outer scope.
-                     * -------------------------------------------------
-                     * We need to replace the shortcut
-
-                        QtCore.Qt.AlignLeft
-
-                     * by the correct call
-
-                        QtCore.Qt.AlignmentFlag.AlignLeft
-
-                     * That means: We need to search all Enums of the class.
-                     */
-                    if (Py_TYPE(value) == EnumMeta) {
-                        auto *valtype = reinterpret_cast<PyTypeObject *>(value);
-                        auto *member_map = PyDict_GetItem(valtype->tp_dict, _member_map_);
-                        if (member_map && PyDict_Check(member_map)) {
-                            auto *result = PyDict_GetItem(member_map, name);
-                            if (result) {
-                                Py_INCREF(result);
-                                return result;
-                            }
-                        }
-                    }
-                }
-            }
+        ret = lookupUnqualifiedOrOldEnum(type, name);
+        if (ret) {
+            Py_DECREF(error_type);
+            Py_XDECREF(error_value);
+            Py_XDECREF(error_traceback);
+        } else {
+            PyErr_Restore(error_type, error_value, error_traceback);
         }
-        PyErr_Restore(error_type, error_value, error_traceback);
     }
     return ret;
 }
@@ -337,11 +368,15 @@ PyObject *Sbk_TypeGet___dict__(PyTypeObject *type, void * /* context */)
     /*
      * This is the override for getting a dict.
      */
-    auto dict = type->tp_dict;
+    AutoDecRef tpDict(PepType_GetDict(type));
+    auto *dict = tpDict.object();;
     if (dict == nullptr)
         Py_RETURN_NONE;
-    if (SelectFeatureSet != nullptr)
-        dict = SelectFeatureSet(type);
+    if (SelectFeatureSet != nullptr) {
+        SelectFeatureSet(type);
+        tpDict.reset(PepType_GetDict(type));
+        dict = tpDict.object();
+    }
     return PyDictProxy_New(dict);
 }
 
@@ -352,7 +387,7 @@ PyObject *SbkObject_GenericGetAttr(PyObject *obj, PyObject *name)
 {
     auto type = Py_TYPE(obj);
     if (SelectFeatureSet != nullptr)
-        type->tp_dict = SelectFeatureSet(type);
+        SelectFeatureSet(type);
     return PyObject_GenericGetAttr(obj, name);
 }
 
@@ -360,21 +395,10 @@ int SbkObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
 {
     auto type = Py_TYPE(obj);
     if (SelectFeatureSet != nullptr)
-        type->tp_dict = SelectFeatureSet(type);
+        SelectFeatureSet(type);
     return PyObject_GenericSetAttr(obj, name, value);
 }
 
-// Caching the select Id.
-int SbkObjectType_GetReserved(PyTypeObject *type)
-{
-    return PepType_SOTP(type)->pyside_reserved_bits;
-}
-
-void SbkObjectType_SetReserved(PyTypeObject *type, int value)
-{
-    PepType_SOTP(type)->pyside_reserved_bits = value;
-}
-
 const char **SbkObjectType_GetPropertyStrings(PyTypeObject *type)
 {
     return PepType_SOTP(type)->propertyStrings;
@@ -394,7 +418,7 @@ void SbkObjectType_SetEnumFlagInfo(PyTypeObject *type, const char **strings)
 void SbkObjectType_UpdateFeature(PyTypeObject *type)
 {
     if (SelectFeatureSet != nullptr)
-        type->tp_dict = SelectFeatureSet(type);
+        SelectFeatureSet(type);
 }
 
 } // extern "C"
diff --git a/sources/shiboken6/libshiboken/sbkfeature_base.h b/sources/shiboken6/libshiboken/sbkfeature_base.h
index 8d55297d7..290884062 100644
--- a/sources/shiboken6/libshiboken/sbkfeature_base.h
+++ b/sources/shiboken6/libshiboken/sbkfeature_base.h
@@ -7,9 +7,7 @@
 extern "C"
 {
 
-LIBSHIBOKEN_API PyObject *getFeatureSelectId();
 LIBSHIBOKEN_API int currentSelectId(PyTypeObject *type);
-LIBSHIBOKEN_API void initFeatureShibokenPart();
 LIBSHIBOKEN_API PyObject *mangled_type_getattro(PyTypeObject *type, PyObject *name);
 LIBSHIBOKEN_API PyObject *Sbk_TypeGet___dict__(PyTypeObject *type, void *context);
 LIBSHIBOKEN_API PyObject *SbkObject_GenericGetAttr(PyObject *obj, PyObject *name);
diff --git a/sources/shiboken6/libshiboken/sbkmodule.cpp b/sources/shiboken6/libshiboken/sbkmodule.cpp
index aeae34a36..6b080d5fb 100644
--- a/sources/shiboken6/libshiboken/sbkmodule.cpp
+++ b/sources/shiboken6/libshiboken/sbkmodule.cpp
@@ -2,54 +2,508 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #include "sbkmodule.h"
+#include "autodecref.h"
 #include "basewrapper.h"
 #include "bindingmanager.h"
+#include "sbkstring.h"
+#include "sbkcppstring.h"
+#include "sbkconverter_p.h"
+
 #include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <cstring>
+
+/// This hash maps module objects to arrays of converters.
+using ModuleConvertersMap = std::unordered_map<PyObject *, SbkConverter **> ;
 
 /// This hash maps module objects to arrays of Python types.
-using ModuleTypesMap = std::unordered_map<PyObject *, PyTypeObject **> ;
+using ModuleTypesMap = std::unordered_map<PyObject *, Shiboken::Module::TypeInitStruct *> ;
 
-/// This hash maps module objects to arrays of converters.
-using ModuleConvertersMap = std::unordered_map<PyObject *, SbkConverter **>;
+struct TypeCreationStruct
+{
+    Shiboken::Module::TypeCreationFunction func;
+    std::vector<std::string> subtypeNames;
+};
+
+/// This hash maps type names to type creation structs.
+using NameToTypeFunctionMap = std::unordered_map<std::string, TypeCreationStruct> ;
+
+/// This hash maps module objects to maps of names to functions.
+using ModuleToFuncsMap = std::unordered_map<PyObject *, NameToTypeFunctionMap> ;
 
 /// All types produced in imported modules are mapped here.
 static ModuleTypesMap moduleTypes;
 static ModuleConvertersMap moduleConverters;
+static ModuleToFuncsMap moduleToFuncs;
 
 namespace Shiboken
 {
 namespace Module
 {
 
+// PYSIDE-2404: Replacing the arguments generated by cpythonTypeNameExt
+//              by a function call.
+LIBSHIBOKEN_API PyTypeObject *get(TypeInitStruct &typeStruct)
+{
+    if (typeStruct.type != nullptr)
+        return typeStruct.type;
+
+    static PyObject *sysModules = PyImport_GetModuleDict();
+
+    // The slow path for initialization.
+    // We get the type by following the chain from the module.
+    // As soon as types[index] gets filled, we can stop.
+
+    std::string_view names(typeStruct.fullName);
+    const bool usePySide = names.compare(0, 8, "PySide6.") == 0;
+    auto dotPos = usePySide ? names.find('.', 8) : names.find('.');
+    auto startPos = dotPos + 1;
+    AutoDecRef modName(String::fromCppStringView(names.substr(0, dotPos)));
+    auto *modOrType = PyDict_GetItem(sysModules, modName);
+    if (modOrType == nullptr) {
+        PyErr_Format(PyExc_SystemError, "Module \"%U\" should already be in sys.modules",
+                                        modName.object());
+        return nullptr;
+    }
+
+    do {
+        dotPos = names.find('.', startPos);
+        auto typeName = dotPos != std::string::npos
+                        ? names.substr(startPos, dotPos - startPos)
+                        : names.substr(startPos);
+        startPos = dotPos + 1;
+        AutoDecRef obTypeName(String::fromCppStringView(typeName));
+        modOrType = PyObject_GetAttr(modOrType, obTypeName);
+    } while (typeStruct.type == nullptr && dotPos != std::string::npos);
+
+    return typeStruct.type;
+}
+
+static void incarnateHelper(PyObject *module, const std::string_view names,
+                            const NameToTypeFunctionMap &nameToFunc)
+{
+    auto dotPos = names.find('.');
+    std::string::size_type startPos = 0;
+    auto *modOrType{module};
+    while (dotPos != std::string::npos) {
+        auto typeName = names.substr(startPos, dotPos - startPos);
+        AutoDecRef obTypeName(String::fromCppStringView(typeName));
+        modOrType = PyObject_GetAttr(modOrType, obTypeName);
+        startPos = dotPos + 1;
+        dotPos = names.find('.', startPos);
+    }
+    // now we have the type to create.
+    auto funcIter = nameToFunc.find(std::string(names));
+    // - call this function that returns a PyTypeObject
+    auto tcStruct = funcIter->second;
+    auto initFunc = tcStruct.func;
+    PyTypeObject *type = initFunc(modOrType);
+    auto name = names.substr(startPos);
+    PyObject_SetAttrString(modOrType, name.data(), reinterpret_cast<PyObject *>(type));
+}
+
+static void incarnateSubtypes(PyObject *module,
+                              const std::vector<std::string> &nameList,
+                              NameToTypeFunctionMap &nameToFunc)
+{
+    for (auto const & tableIter : nameList) {
+        std::string_view names(tableIter);
+        incarnateHelper(module, names, nameToFunc);
+    }
+}
+
+static PyTypeObject *incarnateType(PyObject *module, const char *name,
+                                   NameToTypeFunctionMap &nameToFunc)
+{
+    // - locate the name and retrieve the generating function
+    auto funcIter = nameToFunc.find(name);
+    if (funcIter == nameToFunc.end()) {
+        // attribute does really not exist.
+        PyErr_SetNone(PyExc_AttributeError);
+        return nullptr;
+    }
+    // - call this function that returns a PyTypeObject
+    auto tcStruct = funcIter->second;
+    auto initFunc = tcStruct.func;
+    auto *modOrType{module};
+
+    // PYSIDE-2404: Make sure that no switching happens during type creation.
+    auto saveFeature = initSelectableFeature(nullptr);
+    PyTypeObject *type = initFunc(modOrType);
+    if (!tcStruct.subtypeNames.empty())
+        incarnateSubtypes(module, tcStruct.subtypeNames, nameToFunc);
+    initSelectableFeature(saveFeature);
+
+    // - assign this object to the name in the module
+    auto *res = reinterpret_cast<PyObject *>(type);
+    Py_INCREF(res);
+    PyModule_AddObject(module, name, res);   // steals reference
+    // - remove the entry, if not by something cleared.
+    if (!nameToFunc.empty())
+        nameToFunc.erase(funcIter);
+    // - return the PyTypeObject.
+    return type;
+}
+
+// PYSIDE-2404: Make sure that the mentioned classes really exist.
+// Used in `Pyside::typeName`. Because the result will be cached by
+// the creation of the type(s), this is efficient.
+void loadLazyClassesWithName(const char *name)
+{
+    for (auto const & tableIter : moduleToFuncs) {
+        auto nameToFunc = tableIter.second;
+        auto funcIter = nameToFunc.find(name);
+        if (funcIter != nameToFunc.end()) {
+            // attribute exists in the lazy types.
+            auto *module = tableIter.first;
+            incarnateType(module, name, nameToFunc);
+        }
+    }
+}
+
+// PYSIDE-2404: Completely load all not yet loaded classes.
+//              This is needed to resolve a star import.
+void resolveLazyClasses(PyObject *module)
+{
+    // - locate the module in the moduleTofuncs mapping
+    auto tableIter = moduleToFuncs.find(module);
+    if (tableIter == moduleToFuncs.end())
+        return;
+
+    // - see if there are still unloaded elements
+    auto &nameToFunc = tableIter->second;
+
+    // - incarnate all types.
+    while (!nameToFunc.empty()) {
+        auto it = nameToFunc.begin();
+        auto attrNameStr = it->first;
+        incarnateType(module, attrNameStr.c_str(), nameToFunc);
+    }
+}
+
+// PYSIDE-2404: Override the gettattr function of modules.
+static getattrofunc origModuleGetattro{};
+
+// PYSIDE-2404: Use the patched module getattr to do on-demand initialization.
+//              This modifies _all_ modules but should have no impact.
+static PyObject *PyModule_lazyGetAttro(PyObject *module, PyObject *name)
+{
+    // - check if the attribute is present and return it.
+    auto *attr = PyObject_GenericGetAttr(module, name);
+    // - we handle AttributeError, only.
+    if (!(attr == nullptr && PyErr_ExceptionMatches(PyExc_AttributeError)))
+        return attr;
+
+    PyErr_Clear();
+    // - locate the module in the moduleTofuncs mapping
+    auto tableIter = moduleToFuncs.find(module);
+    // - if this is not our module, use the original
+    if (tableIter == moduleToFuncs.end())
+        return origModuleGetattro(module, name);
+
+    // - locate the name and retrieve the generating function
+    const char *attrNameStr = Shiboken::String::toCString(name);
+    auto &nameToFunc = tableIter->second;
+    // - create the real type and handle subtypes
+    auto *type = incarnateType(module, attrNameStr, nameToFunc);
+    auto *ret = reinterpret_cast<PyObject *>(type);
+    // - if attribute does really not exist use the original
+    if (ret == nullptr && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+        return origModuleGetattro(module, name);
+    }
+    return ret;
+}
+
+// PYSIDE-2404: Supply a new module dir for not yet visible entries.
+//              This modification is only for "our" modules.
+static PyObject *_module_dir_template(PyObject * /* self */, PyObject *args)
+{
+    static PyObject *const _dict = Shiboken::String::createStaticString("__dict__");
+    // The dir function must replace all of the builtin function.
+    PyObject *module{};
+    if (!PyArg_ParseTuple(args, "O", &module))
+        return nullptr;
+
+    auto tableIter = moduleToFuncs.find(module);
+    assert(tableIter != moduleToFuncs.end());
+    Shiboken::AutoDecRef dict(PyObject_GetAttr(module, _dict));
+    auto *ret = PyDict_Keys(dict);
+    // Now add all elements that were not yet in the dict.
+    auto &nameToFunc = tableIter->second;
+    for (const auto &funcIter : nameToFunc) {
+        const char *name = funcIter.first.c_str();
+        Shiboken::AutoDecRef pyName(PyUnicode_FromString(name));
+        PyList_Append(ret, pyName);
+    }
+    return ret;
+}
+
+static PyMethodDef module_methods[] = {
+    {"__dir__", (PyCFunction)_module_dir_template, METH_VARARGS, nullptr},
+    {nullptr, nullptr, 0, nullptr}
+};
+
+// Python 3.8 - 3.12
+static int const LOAD_CONST_312 = 100;
+static int const IMPORT_NAME_312 = 108;
+
+static bool isImportStar(PyObject *module)
+{
+    // Find out whether we have a star import. This must work even
+    // when we have no import support from feature.
+    static PyObject *const _f_code = Shiboken::String::createStaticString("f_code");
+    static PyObject *const _f_lasti = Shiboken::String::createStaticString("f_lasti");
+    static PyObject *const _f_back = Shiboken::String::createStaticString("f_back");
+    static PyObject *const _co_code = Shiboken::String::createStaticString("co_code");
+    static PyObject *const _co_consts = Shiboken::String::createStaticString("co_consts");
+    static PyObject *const _co_names = Shiboken::String::createStaticString("co_names");
+
+    auto *obFrame = reinterpret_cast<PyObject *>(PyEval_GetFrame());
+    if (obFrame == nullptr)
+        return true;            // better assume worst-case.
+
+    Py_INCREF(obFrame);
+    AutoDecRef dec_frame(obFrame);
+
+    // Calculate the offset of the running import_name opcode on the stack.
+    // Right before that there must be a load_const with the tuple `("*",)`.
+    while (dec_frame.object() != Py_None) {
+        AutoDecRef dec_f_code(PyObject_GetAttr(dec_frame, _f_code));
+        AutoDecRef dec_co_code(PyObject_GetAttr(dec_f_code, _co_code));
+        AutoDecRef dec_f_lasti(PyObject_GetAttr(dec_frame, _f_lasti));
+        Py_ssize_t f_lasti = PyLong_AsSsize_t(dec_f_lasti);
+        Py_ssize_t code_len;
+        char *co_code{};
+        PyBytes_AsStringAndSize(dec_co_code, &co_code, &code_len);
+        uint8_t opcode2 = co_code[f_lasti];
+        uint8_t opcode1 = co_code[f_lasti - 2];
+        if (opcode1 == LOAD_CONST_312 && opcode2 == IMPORT_NAME_312) {
+            uint8_t oparg1 = co_code[f_lasti - 1];
+            uint8_t oparg2 = co_code[f_lasti + 1];
+            AutoDecRef dec_co_consts(PyObject_GetAttr(dec_f_code, _co_consts));
+            auto *fromlist = PyTuple_GetItem(dec_co_consts, oparg1);
+            if (PyTuple_Check(fromlist) && PyTuple_Size(fromlist) == 1
+                    && Shiboken::String::toCString(PyTuple_GetItem(fromlist, 0))[0] == '*') {
+                AutoDecRef dec_co_names(PyObject_GetAttr(dec_f_code, _co_names));
+                const char *name = String::toCString(PyTuple_GetItem(dec_co_names, oparg2));
+                const char *modName = PyModule_GetName(module);
+                if (std::strcmp(name, modName) == 0)
+                    return true;
+            }
+        }
+        dec_frame.reset(PyObject_GetAttr(dec_frame, _f_back));
+    }
+    return false;
+}
+
+// PYSIDE-2404: These modules produce ambiguous names which we cannot handle, yet.
+static std::unordered_set<std::string> dontLazyLoad{
+    "testbinding"
+};
+
+static const std::unordered_set<std::string> knownModules{
+    "shiboken6.Shiboken",
+    "minimal",
+    "other",
+    "sample",
+    "smart",
+    "scriptableapplication",
+    "testbinding"
+};
+
+static bool canNotLazyLoad(PyObject *module)
+{
+    const char *modName = PyModule_GetName(module);
+
+    // There are no more things that must be disabled :-D
+    return dontLazyLoad.find(modName) != dontLazyLoad.end();
+}
+
+static bool shouldLazyLoad(PyObject *module)
+{
+    const char *modName = PyModule_GetName(module);
+
+    if (knownModules.find(modName) != knownModules.end())
+        return true;
+    return std::strncmp(modName, "PySide6.", 8) == 0;
+}
+
+static int lazyLoadDefault()
+{
+#ifndef PYPY_VERSION
+    int result = 1;
+#else
+    int result = 0;
+#endif
+    if (auto *flag = getenv("PYSIDE6_OPTION_LAZY"))
+        result = std::atoi(flag);
+    return result;
+}
+
+void checkIfShouldLoadImmediately(PyObject *module, const std::string &name,
+                                  const NameToTypeFunctionMap &nameToFunc)
+{
+    static const int value = lazyLoadDefault();
+
+    // PYSIDE-2404: Lazy Loading
+    //
+    // Options:
+    //   0  - switch lazy loading off.
+    //   1  - lazy loading for all known modules.
+    //   3  - lazy loading for any module.
+    //
+    // By default we lazy load all known modules (option = 1).
+    if (value == 0                                  // completely disabled
+        || canNotLazyLoad(module)                   // for some reason we cannot lazy load
+        || (value == 1 && !shouldLazyLoad(module))  // not a known module
+        ) {
+        incarnateHelper(module, name, nameToFunc);
+    }
+}
+
+void AddTypeCreationFunction(PyObject *module,
+                             const char *name,
+                             TypeCreationFunction func)
+{
+    // - locate the module in the moduleTofuncs mapping
+    auto tableIter = moduleToFuncs.find(module);
+    assert(tableIter != moduleToFuncs.end());
+    // - Assign the name/generating function tcStruct.
+    auto &nameToFunc = tableIter->second;
+    TypeCreationStruct tcStruct{func, {}};
+    auto nit = nameToFunc.find(name);
+    if (nit == nameToFunc.end())
+        nameToFunc.insert(std::make_pair(name, tcStruct));
+    else
+        nit->second = tcStruct;
+
+    checkIfShouldLoadImmediately(module, name, nameToFunc);
+}
+
+void AddTypeCreationFunction(PyObject *module,
+                             const char *containerName,
+                             TypeCreationFunction func,
+                             const char *namePath)
+{
+    // - locate the module in the moduleTofuncs mapping
+    auto tableIter = moduleToFuncs.find(module);
+    assert(tableIter != moduleToFuncs.end());
+    // - Assign the name/generating function tcStruct.
+    auto &nameToFunc = tableIter->second;
+    auto nit = nameToFunc.find(containerName);
+
+    // - insert namePath into the subtype vector of the main type.
+    nit->second.subtypeNames.push_back(namePath);
+    // - insert it also as its own entry.
+    nit = nameToFunc.find(namePath);
+    TypeCreationStruct tcStruct{func, {}};
+    if (nit == nameToFunc.end())
+        nameToFunc.insert(std::make_pair(namePath, tcStruct));
+    else
+        nit->second = tcStruct;
+
+    checkIfShouldLoadImmediately(module, namePath, nameToFunc);
+}
+
 PyObject *import(const char *moduleName)
 {
     PyObject *sysModules = PyImport_GetModuleDict();
     PyObject *module = PyDict_GetItemString(sysModules, moduleName);
-    if (module)
+    if (module != nullptr)
         Py_INCREF(module);
     else
         module = PyImport_ImportModule(moduleName);
 
-    if (!module)
-        PyErr_Format(PyExc_ImportError,"could not import module '%s'", moduleName);
+    if (module == nullptr)
+        PyErr_Format(PyExc_ImportError, "could not import module '%s'", moduleName);
 
     return module;
 }
 
-PyObject *create(const char * /* moduleName */, void *moduleData)
+// PYSIDE-2404: Redirecting import for "import *" support.
+//
+// The first import will be handled by the isImportStar function.
+// But the same module might be imported twice, which would give no
+// introspection due to module caching.
+
+static PyObject *origImportFunc{};
+
+static PyObject *lazy_import(PyObject * /* self */, PyObject *args, PyObject *kwds)
+{
+    auto *ret = PyObject_Call(origImportFunc, args, kwds);
+    if (ret != nullptr) {
+        // PYSIDE-2404: Support star import when lazy loading.
+        if (PyTuple_Size(args) >= 4) {
+            auto *fromlist = PyTuple_GetItem(args, 3);
+            if (PyTuple_Check(fromlist) && PyTuple_Size(fromlist) == 1
+                    && Shiboken::String::toCString(PyTuple_GetItem(fromlist, 0))[0] == '*')
+                Shiboken::Module::resolveLazyClasses(ret);
+        }
+    }
+    return ret;
+}
+
+static PyMethodDef lazy_methods[] = {
+    {"__lazy_import__", (PyCFunction)lazy_import, METH_VARARGS | METH_KEYWORDS, nullptr},
+    {nullptr, nullptr, 0, nullptr}
+};
+
+PyObject *create(const char * /* modName */, void *moduleData)
 {
+    static auto *sysModules = PyImport_GetModuleDict();
+    static auto *builtins = PyEval_GetBuiltins();
+    static auto *partial = Pep_GetPartialFunction();
+    static bool lazy_init{};
+
     Shiboken::init();
-    return PyModule_Create(reinterpret_cast<PyModuleDef *>(moduleData));
+    auto *module = PyModule_Create(reinterpret_cast<PyModuleDef *>(moduleData));
+
+    // Setup of a dir function for "missing" classes.
+    auto *moduleDirTemplate = PyCFunction_NewEx(module_methods, nullptr, nullptr);
+    // Turn this function into a bound object, so we have access to the module.
+    auto *moduleDir = PyObject_CallFunctionObjArgs(partial, moduleDirTemplate, module, nullptr);
+    PyModule_AddObject(module, module_methods->ml_name, moduleDir);  // steals reference
+    // Insert an initial empty table for the module.
+    NameToTypeFunctionMap empty;
+    moduleToFuncs.insert(std::make_pair(module, empty));
+
+    // A star import must be done unconditionally. Use the complete name.
+    if (isImportStar(module))
+        dontLazyLoad.insert(PyModule_GetName(module));
+
+    if (!lazy_init) {
+        // Install the getattr patch.
+        origModuleGetattro = PyModule_Type.tp_getattro;
+        PyModule_Type.tp_getattro = PyModule_lazyGetAttro;
+        // Add the lazy import redirection.
+        origImportFunc = PyDict_GetItemString(builtins, "__import__");
+        auto *func = PyCFunction_NewEx(lazy_methods, nullptr, nullptr);
+        PyDict_SetItemString(builtins, "__import__", func);
+        // Everything is set.
+        lazy_init = true;
+    }
+    // PYSIDE-2404: Nuitka inserts some additional code in standalone mode
+    //              in an invisible virtual module (i.e. `QtCore-postLoad`)
+    //              that gets imported before the running import can call
+    //              `_PyImport_FixupExtensionObject` which does the insertion
+    //              into `sys.modules`. This can cause a race condition.
+    // Insert the module early into the module dict to prevend recursion.
+    PyDict_SetItemString(sysModules, PyModule_GetName(module), module);
+    // Clear the non-existing name cache because we have a new module.
+    Shiboken::Conversions::clearNegativeLazyCache();
+    return module;
 }
 
-void registerTypes(PyObject *module, PyTypeObject **types)
+void registerTypes(PyObject *module, TypeInitStruct *types)
 {
     auto iter = moduleTypes.find(module);
     if (iter == moduleTypes.end())
         moduleTypes.insert(std::make_pair(module, types));
 }
 
-PyTypeObject **getTypes(PyObject *module)
+TypeInitStruct *getTypes(PyObject *module)
 {
     auto iter = moduleTypes.find(module);
     return (iter == moduleTypes.end()) ? 0 : iter->second;
diff --git a/sources/shiboken6/libshiboken/sbkmodule.h b/sources/shiboken6/libshiboken/sbkmodule.h
index a4f7837f5..2c407e09d 100644
--- a/sources/shiboken6/libshiboken/sbkmodule.h
+++ b/sources/shiboken6/libshiboken/sbkmodule.h
@@ -12,8 +12,22 @@ extern "C"
 struct SbkConverter;
 }
 
-namespace Shiboken {
-namespace Module {
+namespace Shiboken::Module {
+
+struct TypeInitStruct
+{
+    PyTypeObject *type;
+    const char *fullName;
+};
+
+/// PYSIDE-2404: Replacing the arguments in cpythonTypeNameExt by a function.
+LIBSHIBOKEN_API PyTypeObject *get(TypeInitStruct &typeStruct);
+
+/// PYSIDE-2404: Make sure that mentioned classes really exist.
+LIBSHIBOKEN_API void loadLazyClassesWithName(const char *name);
+
+/// PYSIDE-2404: incarnate all classes for star imports.
+LIBSHIBOKEN_API void resolveLazyClasses(PyObject *module);
 
 /**
  *  Imports and returns the module named \p moduleName, or a NULL pointer in case of failure.
@@ -30,19 +44,31 @@ LIBSHIBOKEN_API PyObject *import(const char *moduleName);
  */
 LIBSHIBOKEN_API PyObject *create(const char *moduleName, void *moduleData);
 
+using TypeCreationFunction = PyTypeObject *(*)(PyObject *module);
+
+/// Adds a type creation function to the module.
+LIBSHIBOKEN_API void AddTypeCreationFunction(PyObject *module,
+                                             const char *name,
+                                             TypeCreationFunction func);
+
+LIBSHIBOKEN_API void AddTypeCreationFunction(PyObject *module,
+                                             const char *name,
+                                             TypeCreationFunction func,
+                                             const char *containerName);
+
 /**
  *  Registers the list of types created by \p module.
  *  \param module   Module where the types were created.
  *  \param types    Array of PyTypeObject *objects representing the types created on \p module.
  */
-LIBSHIBOKEN_API void registerTypes(PyObject *module, PyTypeObject **types);
+LIBSHIBOKEN_API void registerTypes(PyObject *module, TypeInitStruct *types);
 
 /**
  *  Retrieves the array of types.
  *  \param module   Module where the types were created.
  *  \returns        A pointer to the PyTypeObject *array of types.
  */
-LIBSHIBOKEN_API PyTypeObject **getTypes(PyObject *module);
+LIBSHIBOKEN_API TypeInitStruct *getTypes(PyObject *module);
 
 /**
  *  Registers the list of converters created by \p module for non-wrapper types.
@@ -58,6 +84,6 @@ LIBSHIBOKEN_API void registerTypeConverters(PyObject *module, SbkConverter **con
  */
 LIBSHIBOKEN_API SbkConverter **getTypeConverters(PyObject *module);
 
-} } // namespace Shiboken::Module
+} // namespace Shiboken::Module
 
 #endif // SBK_MODULE_H
diff --git a/sources/shiboken6/libshiboken/sbknumpy.cpp b/sources/shiboken6/libshiboken/sbknumpy.cpp
index 060a2b6f4..b6422e73f 100644
--- a/sources/shiboken6/libshiboken/sbknumpy.cpp
+++ b/sources/shiboken6/libshiboken/sbknumpy.cpp
@@ -17,9 +17,27 @@
 namespace Shiboken::Numpy
 {
 
+#ifdef HAVE_NUMPY
+static void initNumPy()
+{
+    // PYSIDE-2404: Delay-initialize numpy from check() as it causes a
+    // significant startup delay (~770 allocations in memray)
+    static bool initialized = false;
+    if (initialized)
+        return;
+    initialized = true;
+    // Expanded from macro "import_array" in __multiarray_api.h
+    // Make sure to read about the magic defines PY_ARRAY_UNIQUE_SYMBOL etc.,
+    // when changing this or spreading the code over several source files.
+    if (_import_array() < 0)
+        PyErr_Print();
+}
+#endif // HAVE_NUMPY
+
 bool check(PyObject *pyIn)
 {
 #ifdef HAVE_NUMPY
+    initNumPy();
     return PyArray_Check(pyIn);
 #else
     SBK_UNUSED(pyIn);
diff --git a/sources/shiboken6/libshiboken/sbknumpyarrayconverter.cpp b/sources/shiboken6/libshiboken/sbknumpyarrayconverter.cpp
index c8541adf5..835a97524 100644
--- a/sources/shiboken6/libshiboken/sbknumpyarrayconverter.cpp
+++ b/sources/shiboken6/libshiboken/sbknumpyarrayconverter.cpp
@@ -94,8 +94,7 @@ std::ostream &operator<<(std::ostream &str, PyArrayObject *o)
     return str;
 }
 
-namespace Shiboken {
-namespace Conversions {
+namespace Shiboken::Conversions {
 
 // Internals from sbkarrayconverter.cpp
 SbkArrayConverter *createArrayConverter(IsArrayConvertibleToCppFunc toCppCheckFunc);
@@ -105,6 +104,7 @@ SbkArrayConverter *unimplementedArrayConverter();
 template <int dimension>
 static bool isPrimitiveArray(PyObject *pyIn, int expectedNpType)
 {
+    Shiboken::Numpy::initNumPy();
     if (!PyArray_Check(pyIn))
         return false;
     auto *pya = reinterpret_cast<PyArrayObject *>(pyIn);
@@ -210,6 +210,9 @@ static PythonToCppFunc checkArray2(PyObject *pyIn, int dim1, int dim2)
 template <class T>
 static void setOrExtendArrayConverter(int dimension, IsArrayConvertibleToCppFunc toCppCheckFunc)
 {
+    // PYSIDE-2404/FIXME: When adding a C++ -> Python conversion, be sure
+    // to delay-initialize numpy in the converter (similar to the
+    // initialization in check() for the Python -> C++ conversion).
     SbkArrayConverter *arrayConverter = ArrayTypeConverter<T>(dimension);
     if (arrayConverter == unimplementedArrayConverter()) {
         arrayConverter = createArrayConverter(toCppCheckFunc);
@@ -235,15 +238,6 @@ static inline void extendArrayConverter2()
 
 void initNumPyArrayConverters()
 {
-    // Expanded from macro "import_array" in __multiarray_api.h
-    // Make sure to read about the magic defines PY_ARRAY_UNIQUE_SYMBOL etc.,
-    // when changing this or spreading the code over several source files.
-    if (_import_array() < 0) {
-        if (debugNumPy)
-            PyErr_Print();
-        PyErr_Clear();
-        return;
-    }
     // Extend the converters for primitive types by NumPy ones.
     extendArrayConverter1<short, NPY_SHORT>();
     extendArrayConverter2<short, NPY_SHORT>();
@@ -273,5 +267,4 @@ void initNumPyArrayConverters()
     extendArrayConverter2<double, NPY_DOUBLE>();
 }
 
-} // namespace Conversions
-} // namespace Shiboken
+} // namespace Shiboken::Conversions
diff --git a/sources/shiboken6/libshiboken/sbknumpyview.cpp b/sources/shiboken6/libshiboken/sbknumpyview.cpp
index 44a4b5587..bafbf8038 100644
--- a/sources/shiboken6/libshiboken/sbknumpyview.cpp
+++ b/sources/shiboken6/libshiboken/sbknumpyview.cpp
@@ -6,12 +6,54 @@
 #include "helper.h"
 #include <iostream>
 #include <iomanip>
+#include <optional>
 
 #ifdef HAVE_NUMPY
 
 namespace Shiboken {
 namespace Numpy {
 
+static std::optional<View::Type> viewTypeFromNumPy(int npt)
+{
+    switch (npt) {
+    case NPY_SHORT:
+        return View::Int16;
+    case NPY_USHORT:
+        return View::Unsigned16;
+    case NPY_INT:
+        return View::Int;
+    case NPY_UINT:
+        return View::Unsigned;
+    case NPY_LONG:
+        if constexpr (sizeof(long) == sizeof(int))
+            return View::Int;
+        if constexpr (sizeof(long) == sizeof(int64_t))
+            return View::Int64;
+        break;
+    case NPY_ULONG:
+        if constexpr (sizeof(long) == sizeof(int))
+            return View::Unsigned;
+        if constexpr (sizeof(long) == sizeof(int64_t))
+            return View::Unsigned64;
+        break;
+    case NPY_LONGLONG:
+        if constexpr (sizeof(long long) == 8)
+            return View::Int64;
+        break;
+    case NPY_ULONGLONG:
+        if constexpr (sizeof(long long) == 8)
+            return View::Unsigned64;
+        break;
+    case NPY_FLOAT:
+        return View::Float;
+    case NPY_DOUBLE:
+        return View::Double;
+    default:
+        break;
+    }
+    return {};
+}
+
 View View::fromPyObject(PyObject *pyIn)
 {
     if (pyIn == nullptr || PyArray_Check(pyIn) == 0)
@@ -23,27 +65,13 @@ View View::fromPyObject(PyObject *pyIn)
     if (ndim > 2)
         return {};
 
-    View::Type type;
-    switch (PyArray_TYPE(ar)) {
-    case NPY_INT:
-        type = View::Int;
-        break;
-    case NPY_UINT:
-        type = View::Unsigned;
-        break;
-    case NPY_FLOAT:
-        type = View::Float;
-        break;
-    case NPY_DOUBLE:
-        type = View::Double;
-        break;
-    default:
+    const auto typeO = viewTypeFromNumPy(PyArray_TYPE(ar));
+    if (!typeO.has_value())
         return {};
-    }
 
     View result;
     result.ndim = ndim;
-    result.type = type;
+    result.type = typeO.value();
     result.data = PyArray_DATA(ar);
     result.dimensions[0] = PyArray_DIMS(ar)[0];
     result.stride[0] = PyArray_STRIDES(ar)[0];
@@ -91,11 +119,29 @@ std::ostream &operator<<(std::ostream &str, const debugPyArrayObject &a)
         }
         str << "], type=";
         switch (type) {
+        case NPY_SHORT:
+            str << "short";
+            break;
+        case NPY_USHORT:
+            str << "ushort";
+            break;
         case NPY_INT:
-            str << "int";
+            str << "int32";
             break;
         case NPY_UINT:
-            str << "uint";
+            str << "uint32";
+            break;
+        case NPY_LONG:
+            str << "long";
+            break;
+        case NPY_ULONG:
+            str << "ulong";
+            break;
+        case NPY_LONGLONG:
+            str << "long long";
+            break;
+        case NPY_ULONGLONG:
+            str << "ulong long";
             break;
         case NPY_FLOAT:
             str << "float";
@@ -122,12 +168,30 @@ std::ostream &operator<<(std::ostream &str, const debugPyArrayObject &a)
         if (const int dim0 = PyArray_DIMS(ar)[0]) {
             auto *data = PyArray_DATA(ar);
             switch (type) {
+            case NPY_SHORT:
+                debugArray(str, reinterpret_cast<const short *>(data), dim0);
+                break;
+            case NPY_USHORT:
+                debugArray(str, reinterpret_cast<const unsigned short *>(data), dim0);
+                break;
             case NPY_INT:
                 debugArray(str, reinterpret_cast<const int *>(data), dim0);
                 break;
             case NPY_UINT:
                 debugArray(str, reinterpret_cast<const unsigned *>(data), dim0);
                 break;
+            case NPY_LONG:
+                debugArray(str, reinterpret_cast<const long *>(data), dim0);
+                break;
+            case NPY_ULONG:
+                debugArray(str, reinterpret_cast<const unsigned long*>(data), dim0);
+                break;
+            case NPY_LONGLONG:
+                debugArray(str, reinterpret_cast<const long long *>(data), dim0);
+                break;
+            case NPY_ULONGLONG:
+                debugArray(str, reinterpret_cast<const unsigned long long *>(data), dim0);
+                break;
             case NPY_FLOAT:
                 debugArray(str, reinterpret_cast<const float *>(data), dim0);
                 break;
diff --git a/sources/shiboken6/libshiboken/sbknumpyview.h b/sources/shiboken6/libshiboken/sbknumpyview.h
index d41e2c716..918913b78 100644
--- a/sources/shiboken6/libshiboken/sbknumpyview.h
+++ b/sources/shiboken6/libshiboken/sbknumpyview.h
@@ -22,7 +22,7 @@ LIBSHIBOKEN_API bool check(PyObject *pyIn);
 /// numpy headers.
 struct LIBSHIBOKEN_API View
 {
-    enum Type { Int, Unsigned, Float, Double};
+    enum Type { Int, Unsigned, Float, Double, Int16, Unsigned16, Int64, Unsigned64 };
 
     static View fromPyObject(PyObject *pyIn);
 
diff --git a/sources/shiboken6/libshiboken/sbksmartpointer.cpp b/sources/shiboken6/libshiboken/sbksmartpointer.cpp
new file mode 100644
index 000000000..ee28f7db8
--- /dev/null
+++ b/sources/shiboken6/libshiboken/sbksmartpointer.cpp
@@ -0,0 +1,58 @@
+// 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 "sbksmartpointer.h"
+#include "sbkstring.h"
+#include "autodecref.h"
+
+#include <unordered_set>
+
+namespace Shiboken::SmartPointer
+{
+
+PyObject *repr(PyObject *pointer, PyObject *pointee)
+{
+    Shiboken::AutoDecRef pointerRepr(Shiboken::String::repr(pointer));
+    if (pointer == nullptr)
+        return pointerRepr.release();
+
+    Shiboken::AutoDecRef pointeeRepr(pointee != nullptr
+                                     ? PyObject_Repr(pointee)
+                                     : Shiboken::String::repr(pointee));
+
+    return PyUnicode_FromFormat("%U (%U)", pointerRepr.object(), pointeeRepr.object());
+}
+
+// __dir__ for a smart pointer. Add the __dir__ entries of the pointee to the list.
+PyObject *dir(PyObject *pointer, PyObject *pointee)
+{
+    if (pointer == nullptr)
+        return PyList_New(0);
+    // Get the pointer's dir entries. Note: PyObject_Dir() cannot be called on
+    // self, will crash. Work around by using the type dict keys.
+    AutoDecRef tpDict(PepType_GetDict(Py_TYPE(pointer)));
+    auto *result = PyMapping_Keys(tpDict);
+
+    if (pointee != nullptr && pointee != Py_None) {
+        // Add the entries of the pointee that do not exist in the pointer's list.
+        // Since Python internally caches strings; we can use a set of PyObject *.
+        std::unordered_set<PyObject *> knownStrings;
+        for (Py_ssize_t i = 0, size = PySequence_Size(result); i < size; ++i) {
+            Shiboken::AutoDecRef item(PySequence_GetItem(result, i));
+            knownStrings.insert(item.object());
+        }
+        const auto knownEnd = knownStrings.end();
+
+        Shiboken::AutoDecRef pointeeDir(PyObject_Dir(pointee));
+        for (Py_ssize_t i = 0, size = PySequence_Size(pointeeDir.object()); i < size; ++i) {
+            Shiboken::AutoDecRef item(PySequence_GetItem(pointeeDir, i));
+            if (knownStrings.find(item.object()) == knownEnd)
+                PyList_Append(result, item.object());
+        }
+    }
+
+    PyList_Sort(result);
+    return result;
+}
+
+} // namespace Shiboken::SmartPointer
diff --git a/sources/shiboken6/libshiboken/sbksmartpointer.h b/sources/shiboken6/libshiboken/sbksmartpointer.h
new file mode 100644
index 000000000..5e2022722
--- /dev/null
+++ b/sources/shiboken6/libshiboken/sbksmartpointer.h
@@ -0,0 +1,18 @@
+// 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 SBK_SBKSMARTPOINTER_H
+#define SBK_SBKSMARTPOINTER_H
+
+#include "sbkpython.h"
+#include "shibokenmacros.h"
+
+namespace Shiboken::SmartPointer
+{
+
+LIBSHIBOKEN_API PyObject *repr(PyObject *pointer, PyObject *pointee);
+LIBSHIBOKEN_API PyObject *dir(PyObject *pointer, PyObject *pointee);
+
+} // namespace Shiboken::SmartPointer
+
+#endif // SBK_SBKSMARTPOINTER_H
diff --git a/sources/shiboken6/libshiboken/sbkstaticstrings.cpp b/sources/shiboken6/libshiboken/sbkstaticstrings.cpp
index 0c8beaabb..023de0ea4 100644
--- a/sources/shiboken6/libshiboken/sbkstaticstrings.cpp
+++ b/sources/shiboken6/libshiboken/sbkstaticstrings.cpp
@@ -24,6 +24,7 @@ STATIC_STRING_IMPL(im_self, "im_self")
 STATIC_STRING_IMPL(loads, "loads")
 STATIC_STRING_IMPL(multi, "multi")
 STATIC_STRING_IMPL(name, "name")
+STATIC_STRING_IMPL(orig_dict, "orig_dict")
 STATIC_STRING_IMPL(qApp, "qApp")
 STATIC_STRING_IMPL(result, "result")
 STATIC_STRING_IMPL(select_id, "select_id")
@@ -75,7 +76,6 @@ STATIC_STRING_IMPL(iter, "__iter__")
 STATIC_STRING_IMPL(mro, "__mro__")
 STATIC_STRING_IMPL(new_, "__new__")
 STATIC_STRING_IMPL(objclass, "__objclass__")
-STATIC_STRING_IMPL(signature, "__signature__")
 STATIC_STRING_IMPL(weakrefoffset, "__weakrefoffset__")
 STATIC_STRING_IMPL(opaque_container, "__opaque_container__")
 } // namespace PyMagicName
diff --git a/sources/shiboken6/libshiboken/sbkstaticstrings.h b/sources/shiboken6/libshiboken/sbkstaticstrings.h
index 02cc8a7f6..017790ee3 100644
--- a/sources/shiboken6/libshiboken/sbkstaticstrings.h
+++ b/sources/shiboken6/libshiboken/sbkstaticstrings.h
@@ -23,6 +23,7 @@ LIBSHIBOKEN_API PyObject *im_self();
 LIBSHIBOKEN_API PyObject *loads();
 LIBSHIBOKEN_API PyObject *multi();
 LIBSHIBOKEN_API PyObject *name();
+LIBSHIBOKEN_API PyObject *orig_dict();
 LIBSHIBOKEN_API PyObject *result();
 LIBSHIBOKEN_API PyObject *select_id();
 LIBSHIBOKEN_API PyObject *value();
diff --git a/sources/shiboken6/libshiboken/sbkstring.cpp b/sources/shiboken6/libshiboken/sbkstring.cpp
index 8f2dc6d52..b5e87ca5a 100644
--- a/sources/shiboken6/libshiboken/sbkstring.cpp
+++ b/sources/shiboken6/libshiboken/sbkstring.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
 
 #include "sbkstring.h"
+#include "sbkenum.h"
 #include "sbkstaticstrings_p.h"
 #include "autodecref.h"
 
@@ -14,6 +15,11 @@ bool checkIterable(PyObject *obj)
     return PyObject_HasAttr(obj, Shiboken::PyMagicName::iter());
 }
 
+bool checkIterableArgument(PyObject *obj)
+{
+    return checkIterable(obj) && !Shiboken::Enum::check(obj);
+}
+
 static PyObject *initPathLike()
 {
     PyObject *PathLike{};
@@ -233,4 +239,16 @@ PyObject *getSnakeCaseName(PyObject *name, bool lower)
     return name;
 }
 
+// Return a generic representation of a PyObject as does PyObject_Repr().
+// Note: PyObject_Repr() may not be called on self from __repr__() as this
+// causes a recursion.
+PyObject *repr(PyObject *o)
+{
+    if (o == nullptr)
+        return PyUnicode_FromString("<NULL>");
+    if (o == Py_None)
+        return PyUnicode_FromString("None");
+     return PyUnicode_FromFormat("<%s object at %p>", Py_TYPE(o)->tp_name, o);
+}
+
 } // namespace Shiboken::String
diff --git a/sources/shiboken6/libshiboken/sbkstring.h b/sources/shiboken6/libshiboken/sbkstring.h
index a24c01def..ebc5428c7 100644
--- a/sources/shiboken6/libshiboken/sbkstring.h
+++ b/sources/shiboken6/libshiboken/sbkstring.h
@@ -13,6 +13,8 @@ namespace String
 {
     LIBSHIBOKEN_API bool check(PyObject *obj);
     LIBSHIBOKEN_API bool checkIterable(PyObject *obj);
+    /// Check for iterable function arguments (excluding enumerations)
+    LIBSHIBOKEN_API bool checkIterableArgument(PyObject *obj);
     LIBSHIBOKEN_API bool checkPath(PyObject *path);
     LIBSHIBOKEN_API bool checkType(PyTypeObject *obj);
     LIBSHIBOKEN_API bool checkChar(PyObject *obj);
@@ -29,6 +31,7 @@ namespace String
     LIBSHIBOKEN_API PyObject *createStaticString(const char *str);
     LIBSHIBOKEN_API PyObject *getSnakeCaseName(const char *name, bool lower);
     LIBSHIBOKEN_API PyObject *getSnakeCaseName(PyObject *name, bool lower);
+    LIBSHIBOKEN_API PyObject *repr(PyObject *o);
 
 } // namespace String
 } // namespace Shiboken
diff --git a/sources/shiboken6/libshiboken/sbktypefactory.cpp b/sources/shiboken6/libshiboken/sbktypefactory.cpp
index 0da1a8e23..079548eed 100644
--- a/sources/shiboken6/libshiboken/sbktypefactory.cpp
+++ b/sources/shiboken6/libshiboken/sbktypefactory.cpp
@@ -7,6 +7,8 @@
 extern "C"
 {
 
+using Shiboken::AutoDecRef;
+
 PyTypeObject *SbkType_FromSpec(PyType_Spec *spec)
 {
     return SbkType_FromSpec_BMDWB(spec, nullptr, nullptr, 0, 0, nullptr);
@@ -37,6 +39,60 @@ static PyObject *_PyType_FromSpecWithBases(PyType_Spec *, PyObject *);
 
 #endif // PYPY_VERSION
 
+// PYSIDE-2230: Not so temporary fix for Python 3.12.
+//              A tp_new is no longer allowed in a meta class.
+//              Hopefully, the Python devs will supply the missing support.
+//              It turned out that they will not fix that, as expected.
+// Note: Python 3.12 is the first version that grabs the metaclass from base classes.
+static PyObject *_PyType_FromSpecWithBasesHack(PyType_Spec *spec,
+                                               PyObject *bases,
+                                               PyTypeObject *meta)
+{
+    PyTypeObject *keepMeta{};
+    newfunc keepNew{};
+    AutoDecRef basesPatch{};
+
+    if (bases) {
+        if (bases == Py_None) {
+            // PYSIDE-2230: This is the SbkObject entry which has no base to provide
+            //              the metaclass. We patch it in by modifying `object`s class.
+            assert(meta);
+            auto *base = reinterpret_cast<PyObject *>(&PyBaseObject_Type);
+            base->ob_type = meta;
+            basesPatch.reset(Py_BuildValue("(O)", &PyBaseObject_Type));
+            bases = basesPatch.object();
+        }
+
+        Py_ssize_t n = PyTuple_GET_SIZE(bases);
+        for (auto idx = 0; idx < n; ++idx) {
+            PyTypeObject *base = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(bases, idx));
+            PyTypeObject *meta = Py_TYPE(base);
+            if (meta->tp_new != PyType_Type.tp_new) {
+                // make sure there is no second meta class
+                assert(keepMeta == nullptr);
+                keepMeta = meta;
+                keepNew = meta->tp_new;
+                meta->tp_new = PyType_Type.tp_new;
+            }
+        }
+    }
+
+#if !defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030C0000
+    auto *ret = PyType_FromMetaclass(meta, nullptr /*module*/, spec, bases);
+#else
+    auto *ret = _PyType_FromSpecWithBases(spec, bases);
+#endif
+
+    if (keepMeta)
+        keepMeta->tp_new = keepNew;
+    if (basesPatch.object()) {
+        // undo the metaclass patch.
+        auto *base = PyTuple_GET_ITEM(basesPatch.object(), 0);
+        base->ob_type = &PyType_Type;
+    }
+    return ret;
+}
+
 PyTypeObject *SbkType_FromSpec_BMDWB(PyType_Spec *spec,
                                      PyObject *bases,
                                      PyTypeObject *meta,
@@ -61,7 +117,7 @@ PyTypeObject *SbkType_FromSpec_BMDWB(PyType_Spec *spec,
     int package_level = atoi(spec->name);
     const char *mod = new_spec.name = colon + 1;
 
-    PyObject *obType = _PyType_FromSpecWithBases(&new_spec, bases);
+    PyObject *obType = _PyType_FromSpecWithBasesHack(&new_spec, bases, meta);
     if (obType == nullptr)
         return nullptr;
 
@@ -73,8 +129,8 @@ PyTypeObject *SbkType_FromSpec_BMDWB(PyType_Spec *spec,
         qual = dot + 1;
     }
     int mlen = qual - mod - 1;
-    Shiboken::AutoDecRef module(Shiboken::String::fromCString(mod, mlen));
-    Shiboken::AutoDecRef qualname(Shiboken::String::fromCString(qual));
+    AutoDecRef module(Shiboken::String::fromCString(mod, mlen));
+    AutoDecRef qualname(Shiboken::String::fromCString(qual));
 
     auto *type = reinterpret_cast<PyTypeObject *>(obType);
 
@@ -98,9 +154,10 @@ PyTypeObject *SbkType_FromSpec_BMDWB(PyType_Spec *spec,
     // PyType_Ready too early. (at least in PyPy, which caused pretty long debugging.)
     auto *ht = reinterpret_cast<PyHeapTypeObject *>(type);
     ht->ht_qualname = qualname;
-    if (PyDict_SetItem(type->tp_dict, Shiboken::PyMagicName::qualname(), qualname))
+    AutoDecRef tpDict(PepType_GetDict(type));
+    if (PyDict_SetItem(tpDict.object(), Shiboken::PyMagicName::qualname(), qualname))
         return nullptr;
-    if (PyDict_SetItem(type->tp_dict, Shiboken::PyMagicName::module(), module))
+    if (PyDict_SetItem(tpDict.object(), Shiboken::PyMagicName::module(), module))
         return nullptr;
     PyType_Ready(type);
 #else
@@ -329,7 +386,7 @@ _PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases)
     /// Here is the only change needed: Do not finalize type creation.
     // if (PyType_Ready(type) < 0)
     //     goto fail;
-    type->tp_dict = PyDict_New();
+    PepType_SetDict(type, PyDict_New());
     /// This is not found in PyPy:
     // if (type->tp_dictoffset) {
     //     res->ht_cached_keys = _PyDict_NewKeysForClass();
diff --git a/sources/shiboken6/libshiboken/sbkversion.h.in b/sources/shiboken6/libshiboken/sbkversion.h.in
index 7f99abc3e..5c0b38fdb 100644
--- a/sources/shiboken6/libshiboken/sbkversion.h.in
+++ b/sources/shiboken6/libshiboken/sbkversion.h.in
@@ -10,8 +10,8 @@
 #define SHIBOKEN_MICRO_VERSION @shiboken_MICRO_VERSION@
 #define SHIBOKEN_RELEASE_LEVEL "final"
 #define SHIBOKEN_SERIAL 0
-#define PYTHON_VERSION_MAJOR @PYTHON_VERSION_MAJOR@
-#define PYTHON_VERSION_MINOR @PYTHON_VERSION_MINOR@
-#define PYTHON_VERSION_PATCH @PYTHON_VERSION_PATCH@
+#define PYTHON_VERSION_MAJOR @Python_VERSION_MAJOR@
+#define PYTHON_VERSION_MINOR @Python_VERSION_MINOR@
+#define PYTHON_VERSION_PATCH @Python_VERSION_PATCH@
 
 #endif
diff --git a/sources/shiboken6/libshiboken/sbkwindows.h b/sources/shiboken6/libshiboken/sbkwindows.h
new file mode 100644
index 000000000..9e753fa5e
--- /dev/null
+++ b/sources/shiboken6/libshiboken/sbkwindows.h
@@ -0,0 +1,17 @@
+// 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
+
+#ifndef SBKWINDOWS_H
+#define SBKWINDOWS_H
+
+#ifdef _WIN32
+#  ifndef NOMINMAX
+#    define NOMINMAX
+#  endif
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#endif
+
+#endif // SBKWINDOWS_H
diff --git a/sources/shiboken6/libshiboken/shiboken.h b/sources/shiboken6/libshiboken/shiboken.h
index 13a15e1f4..fcf777ae0 100644
--- a/sources/shiboken6/libshiboken/shiboken.h
+++ b/sources/shiboken6/libshiboken/shiboken.h
@@ -11,10 +11,10 @@
 #include "gilstate.h"
 #include "threadstatesaver.h"
 #include "helper.h"
+#include "pyobjectholder.h"
 #include "sbkarrayconverter.h"
 #include "sbkconverter.h"
 #include "sbkenum.h"
-#include "sbkenum_p.h"      // PYSIDE-1735: This is during the migration, only.
 #include "sbkerrors.h"
 #include "sbkmodule.h"
 #include "sbkstring.h"
diff --git a/sources/shiboken6/libshiboken/signature.h b/sources/shiboken6/libshiboken/signature.h
index 1cc100f3d..e0130b5a6 100644
--- a/sources/shiboken6/libshiboken/signature.h
+++ b/sources/shiboken6/libshiboken/signature.h
@@ -13,7 +13,6 @@ extern "C"
 LIBSHIBOKEN_API int InitSignatureStrings(PyTypeObject *, const char *[]);
 LIBSHIBOKEN_API void FinishSignatureInitialization(PyObject *, const char *[]);
 LIBSHIBOKEN_API void SetError_Argument(PyObject *, const char *, PyObject *);
-LIBSHIBOKEN_API PyObject *Sbk_TypeGet___signature__(PyObject *, PyObject *);
 LIBSHIBOKEN_API PyObject *Sbk_TypeGet___doc__(PyObject *);
 LIBSHIBOKEN_API PyObject *GetFeatureDict();
 
diff --git a/sources/shiboken6/libshiboken/signature/signature.cpp b/sources/shiboken6/libshiboken/signature/signature.cpp
index 6c28c758b..3255cb56d 100644
--- a/sources/shiboken6/libshiboken/signature/signature.cpp
+++ b/sources/shiboken6/libshiboken/signature/signature.cpp
@@ -21,6 +21,7 @@
 #include "sbkstring.h"
 #include "sbkstaticstrings.h"
 #include "sbkstaticstrings_p.h"
+#include "sbkfeature_base.h"
 
 #include <structmember.h>
 
@@ -196,7 +197,7 @@ PyObject *GetSignature_Wrapper(PyObject *ob, PyObject *modifier)
     PyObject *props = PyDict_GetItem(dict, func_name);
     if (props == nullptr) {
         // handle `__init__` like the class itself
-        if (strcmp(String::toCString(func_name), "__init__") == 0)
+        if (PyUnicode_CompareWithASCIIString(func_name, "__init__") == 0)
             return GetSignature_TypeMod(objclass, modifier);
         Py_RETURN_NONE;
     }
@@ -226,6 +227,8 @@ PyObject *GetSignature_TypeMod(PyObject *ob, PyObject *modifier)
 // The `modifier` argument is a string that is passed in from `loader.py`.
 // Configuration what the modifiers mean is completely in Python.
 //
+// PYSIDE-2101: The __signature__ attribute is gone due to rlcompleter.
+//
 
 PyObject *get_signature_intern(PyObject *ob, PyObject *modifier)
 {
@@ -245,6 +248,9 @@ PyObject *get_signature_intern(PyObject *ob, PyObject *modifier)
         return pyside_tp_get___signature__(ob, modifier);
     if (Py_TYPE(ob) == &PyWrapperDescr_Type)
         return pyside_wd_get___signature__(ob, modifier);
+    // For classmethods we use the simple wrapper description implementation.
+    if (Py_TYPE(ob) == &PyClassMethodDescr_Type)
+        return pyside_wd_get___signature__(ob, modifier);
     return nullptr;
 }
 
@@ -284,13 +290,24 @@ static PyObject *feature_import(PyObject * /* self */, PyObject *args, PyObject
     if (import_func == nullptr) {
         Py_FatalError("builtins has no \"__orig_import__\" function");
     }
-    return PyObject_Call(import_func, args, kwds);
+    ret = PyObject_Call(import_func, args, kwds);
+    if (ret) {
+        // PYSIDE-2029: Intercept after the import to search for PySide usage.
+        PyObject *post = PyObject_CallFunctionObjArgs(pyside_globals->feature_imported_func,
+                                                      ret, nullptr);
+        Py_XDECREF(post);
+        if (post == nullptr) {
+            Py_DECREF(ret);
+            return nullptr;
+        }
+    }
+    return ret;
 }
 
 PyMethodDef signature_methods[] = {
     {"__feature_import__", (PyCFunction)feature_import, METH_VARARGS | METH_KEYWORDS, nullptr},
     {"get_signature", (PyCFunction)get_signature, METH_VARARGS,
-        "get the __signature__, but pass an optional string parameter"},
+        "get the signature, passing an optional string parameter"},
     {nullptr, nullptr, 0, nullptr}
 };
 
@@ -373,9 +390,7 @@ PyObject *PySide_BuildSignatureProps(PyObject *type_key)
 #ifdef PYPY_VERSION
 static bool get_lldebug_flag()
 {
-    PyObject *sysmodule = PyImport_AddModule("sys");
-    auto *dic = PyModule_GetDict(sysmodule);
-    dic = PyDict_GetItemString(dic, "pypy_translation_info");
+    auto *dic = PySys_GetObject("pypy_translation_info");
     int lldebug = PyObject_IsTrue(PyDict_GetItemString(dic, "translation.lldebug"));
     int lldebug0 = PyObject_IsTrue(PyDict_GetItemString(dic, "translation.lldebug0"));
     return lldebug || lldebug0;
@@ -416,8 +431,6 @@ static int PySide_FinishSignatures(PyObject *module, const char *signatures[])
         if (PyCFunction_Check(func))
             if (PyDict_SetItem(pyside_globals->map_dict, func, module) < 0)
                 return -1;
-    if (_finish_nested_classes(obdict) < 0)
-        return -1;
     // The finish_import function will not work the first time since phase 2
     // was not yet run. But that is ok, because the first import is always for
     // the shiboken module (or a test module).
@@ -439,10 +452,12 @@ static int PySide_FinishSignatures(PyObject *module, const char *signatures[])
 
 int InitSignatureStrings(PyTypeObject *type, const char *signatures[])
 {
+    // PYSIDE-2404: This function now also builds the mapping for static methods.
+    //              It was one missing spot to let Lazy import work.
     init_shibokensupport_module();
     auto *ob_type = reinterpret_cast<PyObject *>(type);
     int ret = PySide_BuildSignatureArgs(ob_type, signatures);
-    if (ret < 0) {
+    if (ret < 0 || _build_func_to_type(ob_type) < 0) {
         PyErr_Print();
         PyErr_SetNone(PyExc_ImportError);
     }
@@ -459,6 +474,8 @@ void FinishSignatureInitialization(PyObject *module, const char *signatures[])
      * Still, it is not possible to call init phase 2 from here,
      * because the import is still running. Do it from Python!
      */
+    init_shibokensupport_module();
+
 #ifndef PYPY_VERSION
     static const bool patch_types = true;
 #else
@@ -522,8 +539,8 @@ static PyObject *adjustFuncName(const char *func_name)
 
     // Find the feature flags
     auto type = reinterpret_cast<PyTypeObject *>(obtype.object());
-    auto dict = type->tp_dict;
-    int id = SbkObjectType_GetReserved(type);
+    AutoDecRef dict(PepType_GetDict(type));
+    int id = currentSelectId(type);
     id = id < 0 ? 0 : id;   // if undefined, set to zero
     auto lower = id & 0x01;
     auto is_prop = id & 0x02;
@@ -571,7 +588,9 @@ void SetError_Argument(PyObject *args, const char *func_name, PyObject *info)
         PyObject *e, *v, *t;
         // Note: These references are all borrowed.
         PyErr_Fetch(&e, &v, &t);
+        Py_DECREF(e);
         info = v;
+        Py_XDECREF(t);
     }
     // PYSIDE-1019: Modify the function name expression according to feature.
     AutoDecRef new_func_name(adjustFuncName(func_name));
@@ -602,14 +621,10 @@ void SetError_Argument(PyObject *args, const char *func_name, PyObject *info)
  * But the __doc__ attribute existed already by inheritance, and calling
  * PyType_Modified() is not supported. So we added the getsets explicitly
  * to the metatype.
+ *
+ * PYSIDE-2101: The __signature__ attribute is gone due to rlcompleter.
  */
 
-PyObject *Sbk_TypeGet___signature__(PyObject *ob, PyObject *modifier)
-{
-    init_shibokensupport_module();
-    return pyside_tp_get___signature__(ob, modifier);
-}
-
 PyObject *Sbk_TypeGet___doc__(PyObject *ob)
 {
     init_shibokensupport_module();
diff --git a/sources/shiboken6/libshiboken/signature/signature_extend.cpp b/sources/shiboken6/libshiboken/signature/signature_extend.cpp
index d571f90f3..7292f8216 100644
--- a/sources/shiboken6/libshiboken/signature/signature_extend.cpp
+++ b/sources/shiboken6/libshiboken/signature/signature_extend.cpp
@@ -70,8 +70,6 @@ PyObject *pyside_cf_get___signature__(PyObject *func, PyObject *modifier)
 PyObject *pyside_sm_get___signature__(PyObject *sm, PyObject *modifier)
 {
     AutoDecRef func(PyObject_GetAttr(sm, PyMagicName::func()));
-    if (Py_TYPE(func) == PepFunction_TypePtr)
-        return PyObject_GetAttr(func, PyMagicName::signature());
     return _get_written_signature(GetSignature_Function, func, modifier);
 }
 
@@ -79,7 +77,7 @@ PyObject *pyside_md_get___signature__(PyObject *ob_md, PyObject *modifier)
 {
     AutoDecRef func(name_key_to_func(ob_md));
     if (func.object() == Py_None)
-        return Py_None;
+        Py_RETURN_NONE;
     if (func.isNull())
         Py_FatalError("missing mapping in MethodDescriptor");
     return pyside_cf_get___signature__(func, modifier);
@@ -123,13 +121,15 @@ static PyObject *handle_doc(PyObject *ob, PyObject *old_descr)
 {
     AutoDecRef ob_type_mod(GetClassOrModOf(ob));
     const char *name;
-    if (PyModule_Check(ob_type_mod.object()))
+    bool isModule = PyModule_Check(ob_type_mod.object());
+    if (isModule)
         name = PyModule_GetName(ob_type_mod.object());
     else
         name = reinterpret_cast<PyTypeObject *>(ob_type_mod.object())->tp_name;
     PyObject *res{};
 
-    if (handle_doc_in_progress || name == nullptr || strncmp(name, "PySide6.", 8) != 0) {
+    if (handle_doc_in_progress || name == nullptr
+        || (isModule && strncmp(name, "PySide6.", 8) != 0)) {
         res = PyObject_CallMethodObjArgs(old_descr, PyMagicName::get(), ob, nullptr);
     } else {
         handle_doc_in_progress++;
@@ -169,59 +169,29 @@ static PyObject *pyside_wd_get___doc__(PyObject *wd)
     return handle_doc(wd, old_wd_doc_descr);
 }
 
-// the default setter for all objects
-static int pyside_set___signature__(PyObject *op, PyObject *value)
-{
-    // By this additional check, this function refuses write access.
-    // We consider both nullptr and Py_None as not been written.
-    AutoDecRef has_val(get_signature_intern(op, nullptr));
-    if (!(has_val.isNull() || has_val == Py_None)) {
-        PyErr_Format(PyExc_AttributeError,
-                     "Attribute '__signature__' of '%.50s' object is not writable",
-                     Py_TYPE(op)->tp_name);
-        return -1;
-    }
-    int ret = value == nullptr ? PyDict_DelItem(pyside_globals->value_dict, op)
-                               : PyDict_SetItem(pyside_globals->value_dict, op, value);
-    Py_XINCREF(value);
-    return ret;
-}
-
 // PYSIDE-535: We cannot patch types easily in PyPy.
 //             Let's use the `get_signature` function, instead.
 static PyGetSetDef new_PyCFunction_getsets[] = {
     {const_cast<char *>("__doc__"),       reinterpret_cast<getter>(pyside_cf_get___doc__),
                                           nullptr, nullptr, nullptr},
-    {const_cast<char *>("__signature__"), reinterpret_cast<getter>(pyside_cf_get___signature__),
-                                          reinterpret_cast<setter>(pyside_set___signature__),
-                                          nullptr, nullptr},
     {nullptr, nullptr, nullptr, nullptr, nullptr}
 };
 
 static PyGetSetDef new_PyStaticMethod_getsets[] = {
     {const_cast<char *>("__doc__"),       reinterpret_cast<getter>(pyside_sm_get___doc__),
                                           nullptr, nullptr, nullptr},
-    {const_cast<char *>("__signature__"), reinterpret_cast<getter>(pyside_sm_get___signature__),
-                                          reinterpret_cast<setter>(pyside_set___signature__),
-                                          nullptr, nullptr},
     {nullptr, nullptr, nullptr, nullptr, nullptr}
 };
 
 static PyGetSetDef new_PyMethodDescr_getsets[] = {
     {const_cast<char *>("__doc__"),       reinterpret_cast<getter>(pyside_md_get___doc__),
                                           nullptr, nullptr, nullptr},
-    {const_cast<char *>("__signature__"), reinterpret_cast<getter>(pyside_md_get___signature__),
-                                          reinterpret_cast<setter>(pyside_set___signature__),
-                                          nullptr, nullptr},
     {nullptr, nullptr, nullptr, nullptr, nullptr}
 };
 
 static PyGetSetDef new_PyWrapperDescr_getsets[] = {
     {const_cast<char *>("__doc__"),       reinterpret_cast<getter>(pyside_wd_get___doc__),
                                           nullptr, nullptr, nullptr},
-    {const_cast<char *>("__signature__"), reinterpret_cast<getter>(pyside_wd_get___signature__),
-                                          reinterpret_cast<setter>(pyside_set___signature__),
-                                          nullptr, nullptr},
     {nullptr, nullptr, nullptr, nullptr, nullptr}
 };
 
diff --git a/sources/shiboken6/libshiboken/signature/signature_globals.cpp b/sources/shiboken6/libshiboken/signature/signature_globals.cpp
index b861e791a..3a79a12d5 100644
--- a/sources/shiboken6/libshiboken/signature/signature_globals.cpp
+++ b/sources/shiboken6/libshiboken/signature/signature_globals.cpp
@@ -88,11 +88,9 @@ static safe_globals_struc *init_phase_1()
          * Due to MSVC's limitation to 64k strings, we needed to assemble pieces.
          */
         auto **block_ptr = reinterpret_cast<const char **>(PySide_CompressedSignaturePackage);
-        int npieces = 0;
         PyObject *piece{};
         AutoDecRef zipped_string_sequence(PyList_New(0));
         for (; **block_ptr != 0; ++block_ptr) {
-            npieces++;
             // we avoid the string/unicode dilemma by not using PyString_XXX:
             piece = Py_BuildValue("s", *block_ptr);
             if (piece == nullptr || PyList_Append(zipped_string_sequence, piece) < 0)
@@ -186,6 +184,19 @@ static int init_phase_2(safe_globals_struc *p, PyMethodDef *methods)
         p->feature_import_func = PyObject_GetAttrString(loader, "feature_import");
         if (p->feature_import_func == nullptr)
             break;
+        p->feature_imported_func = PyObject_GetAttrString(loader, "feature_imported");
+        if (p->feature_imported_func == nullptr)
+            break;
+
+        // We call stuff like the feature initialization late,
+        // after all the function pointers are in place.
+        PyObject *post_init_func = PyObject_GetAttrString(loader, "post_init");
+        if (post_init_func == nullptr)
+            break;
+        PyObject *ret = PyObject_CallFunctionObjArgs(post_init_func, nullptr);
+        if (ret == nullptr)
+            break;
+
         return 0;
 
     } while (0);
@@ -198,12 +209,12 @@ static int init_phase_2(safe_globals_struc *p, PyMethodDef *methods)
 #ifndef _WIN32
 ////////////////////////////////////////////////////////////////////////////
 // a stack trace for linux-like platforms
-#include <stdio.h>
+#include <cstdio>
 #if defined(__GLIBC__)
 #  include <execinfo.h>
 #endif
 #include <signal.h>
-#include <stdlib.h>
+#include <cstdlib>
 #include <unistd.h>
 
 static void handler(int sig) {
@@ -216,7 +227,7 @@ static void handler(int sig) {
 
     // print out all the frames to stderr
 #endif
-    fprintf(stderr, "Error: signal %d:\n", sig);
+    std::fprintf(stderr, "Error: signal %d:\n", sig);
 #if defined(__GLIBC__)
     backtrace_symbols_fd(array, size, STDERR_FILENO);
 #endif
@@ -226,7 +237,7 @@ static void handler(int sig) {
 ////////////////////////////////////////////////////////////////////////////
 #endif // _WIN32
 
-safe_globals pyside_globals = nullptr;
+safe_globals_struc *pyside_globals = nullptr;
 
 void init_shibokensupport_module(void)
 {
diff --git a/sources/shiboken6/libshiboken/signature/signature_helper.cpp b/sources/shiboken6/libshiboken/signature/signature_helper.cpp
index ef0c021d5..cf84cfa13 100644
--- a/sources/shiboken6/libshiboken/signature/signature_helper.cpp
+++ b/sources/shiboken6/libshiboken/signature/signature_helper.cpp
@@ -51,10 +51,13 @@ int add_more_getsets(PyTypeObject *type, PyGetSetDef *gsp, PyObject **doc_descr)
     /*
      * This function is used to assign a new `__signature__` attribute,
      * and also to override a `__doc__` or `__name__` attribute.
+     *
+     * PYSIDE-2101: The __signature__ attribute is gone due to rlcompleter.
      */
     assert(PyType_Check(type));
     PyType_Ready(type);
-    PyObject *dict = type->tp_dict;
+    AutoDecRef tpDict(PepType_GetDict(type));
+    auto *dict = tpDict.object();
     for (; gsp->name != nullptr; gsp++) {
         PyObject *have_descr = PyDict_GetItemString(dict, gsp->name);
         if (have_descr != nullptr) {
@@ -291,7 +294,7 @@ PyObject *_address_to_stringlist(PyObject *numkey)
     return res_list;
 }
 
-static int _build_func_to_type(PyObject *obtype)
+int _build_func_to_type(PyObject *obtype)
 {
     /*
      * There is no general way to directly get the type of a static method.
@@ -307,7 +310,17 @@ static int _build_func_to_type(PyObject *obtype)
      * We also check for hidden methods, see below.
      */
     auto *type = reinterpret_cast<PyTypeObject *>(obtype);
-    PyObject *dict = type->tp_dict;
+    AutoDecRef tpDict(PepType_GetDict(type));
+    auto *dict = tpDict.object();
+
+    // PYSIDE-2404: Get the original dict for late initialization.
+    //              The dict might have been switched before signature init.
+    static const auto *pyTypeType_tp_dict = PepType_GetDict(&PyType_Type);
+    if (Py_TYPE(dict) != Py_TYPE(pyTypeType_tp_dict)) {
+        tpDict.reset(PyObject_GetAttr(dict, PyName::orig_dict()));
+        dict = tpDict.object();
+    }
+
     PyMethodDef *meth = type->tp_methods;
 
     if (meth == nullptr)
@@ -373,26 +386,4 @@ static int _build_func_to_type(PyObject *obtype)
     return 0;
 }
 
-int _finish_nested_classes(PyObject *obdict)
-{
-    PyObject *key, *value, *obtype;
-    PyTypeObject *subtype;
-    Py_ssize_t pos = 0;
-
-    if (obdict == nullptr)
-        return -1;
-    while (PyDict_Next(obdict, &pos, &key, &value)) {
-        if (PyType_Check(value)) {
-            obtype = value;
-            if (_build_func_to_type(obtype) < 0)
-                return -1;
-            // now continue with nested cases
-            subtype = reinterpret_cast<PyTypeObject *>(obtype);
-            if (_finish_nested_classes(subtype->tp_dict) < 0)
-                return -1;
-        }
-    }
-    return 0;
-}
-
 } // extern "C"
diff --git a/sources/shiboken6/libshiboken/signature_p.h b/sources/shiboken6/libshiboken/signature_p.h
index faa98f93c..d0c4ee537 100644
--- a/sources/shiboken6/libshiboken/signature_p.h
+++ b/sources/shiboken6/libshiboken/signature_p.h
@@ -10,7 +10,7 @@ extern "C" {
 
 // signature_globals.cpp
 
-typedef struct safe_globals_struc {
+struct safe_globals_struc {
     // init part 1: get arg_dict
     PyObject *helper_module;
     PyObject *arg_dict;
@@ -24,9 +24,10 @@ typedef struct safe_globals_struc {
     PyObject *make_helptext_func;
     PyObject *finish_import_func;
     PyObject *feature_import_func;
-} safe_globals_struc, *safe_globals;
+    PyObject *feature_imported_func;
+};
 
-extern safe_globals pyside_globals;
+extern safe_globals_struc *pyside_globals;
 extern PyMethodDef signature_methods[];
 
 void init_shibokensupport_module(void);
@@ -62,6 +63,7 @@ PyObject *_get_class_of_cf(PyObject *ob_cf);
 PyObject *_get_class_of_sm(PyObject *ob_sm);
 PyObject *_get_class_of_descr(PyObject *ob);
 PyObject *_address_to_stringlist(PyObject *numkey);
+int _build_func_to_type(PyObject *obtype);
 int _finish_nested_classes(PyObject *dict);
 
 #ifdef PYPY_VERSION
diff --git a/sources/shiboken6/libshiboken/voidptr.cpp b/sources/shiboken6/libshiboken/voidptr.cpp
index e768ff608..8bb3f6ac8 100644
--- a/sources/shiboken6/libshiboken/voidptr.cpp
+++ b/sources/shiboken6/libshiboken/voidptr.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
 
 #include "voidptr.h"
+#include "pep384ext.h"
 #include "sbkconverter.h"
 #include "basewrapper.h"
 #include "basewrapper_p.h"
@@ -10,12 +11,12 @@ extern "C"
 {
 
 // Void pointer object definition.
-typedef struct {
+struct SbkVoidPtrObject {
     PyObject_HEAD
     void *cptr;
     Py_ssize_t size;
     bool isWritable;
-} SbkVoidPtrObject;
+};
 
 PyObject *SbkVoidPtrObject_new(PyTypeObject *type, PyObject * /* args */, PyObject * /* kwds */)
 {
@@ -24,8 +25,7 @@ PyObject *SbkVoidPtrObject_new(PyTypeObject *type, PyObject * /* args */, PyObje
     // like this, actual call forgotten:
     //    SbkVoidPtrObject *self =
     //        reinterpret_cast<SbkVoidPtrObject *>(type->tp_alloc);
-    PyObject *ob = type->tp_alloc(type, 0);
-    auto *self = reinterpret_cast<SbkVoidPtrObject *>(ob);
+    auto *self = PepExt_TypeCallAlloc<SbkVoidPtrObject>(type, 0);
 
     if (self != nullptr) {
         self->cptr = nullptr;
@@ -156,10 +156,9 @@ PyObject *SbkVoidPtrObject_int(PyObject *v)
 PyObject *toBytes(PyObject *self, PyObject * /* args */)
 {
     auto *sbkObject = reinterpret_cast<SbkVoidPtrObject *>(self);
-    if (sbkObject->size < 0) {
-        PyErr_SetString(PyExc_IndexError, "VoidPtr does not have a size set.");
-        return nullptr;
-    }
+    if (sbkObject->size < 0)
+        return PyErr_Format(PyExc_IndexError, "VoidPtr does not have a size set.");
+
     PyObject *bytes = PyBytes_FromStringAndSize(reinterpret_cast<const char *>(sbkObject->cptr),
                                                 sbkObject->size);
     Py_XINCREF(bytes);
@@ -256,38 +255,42 @@ static PyBufferProcs SbkVoidPtrObjectBufferProc = {
     (releasebufferproc)nullptr                         // bf_releasebuffer
 };
 
-// Void pointer type definition.
-static PyType_Slot SbkVoidPtrType_slots[] = {
-    {Py_tp_repr, reinterpret_cast<void *>(SbkVoidPtrObject_repr)},
-    {Py_nb_int, reinterpret_cast<void *>(SbkVoidPtrObject_int)},
-    {Py_sq_length, reinterpret_cast<void *>(SbkVoidPtrObject_length)},
-    {Py_tp_str, reinterpret_cast<void *>(SbkVoidPtrObject_str)},
-    {Py_tp_richcompare, reinterpret_cast<void *>(SbkVoidPtrObject_richcmp)},
-    {Py_tp_init, reinterpret_cast<void *>(SbkVoidPtrObject_init)},
-    {Py_tp_new, reinterpret_cast<void *>(SbkVoidPtrObject_new)},
-    {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
-    {Py_tp_methods, reinterpret_cast<void *>(SbkVoidPtrObject_methods)},
-    {0, nullptr}
-};
-static PyType_Spec SbkVoidPtrType_spec = {
-    "2:shiboken6.Shiboken.VoidPtr",
-    sizeof(SbkVoidPtrObject),
-    0,
-    Py_TPFLAGS_DEFAULT,
-    SbkVoidPtrType_slots,
-};
-
-
+static PyTypeObject *createVoidPtrType()
+{
+    PyType_Slot SbkVoidPtrType_slots[] = {
+        {Py_tp_repr, reinterpret_cast<void *>(SbkVoidPtrObject_repr)},
+        {Py_nb_int, reinterpret_cast<void *>(SbkVoidPtrObject_int)},
+        {Py_sq_length, reinterpret_cast<void *>(SbkVoidPtrObject_length)},
+        {Py_tp_str, reinterpret_cast<void *>(SbkVoidPtrObject_str)},
+        {Py_tp_richcompare, reinterpret_cast<void *>(SbkVoidPtrObject_richcmp)},
+        {Py_tp_init, reinterpret_cast<void *>(SbkVoidPtrObject_init)},
+        {Py_tp_new, reinterpret_cast<void *>(SbkVoidPtrObject_new)},
+        {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
+        {Py_tp_methods, reinterpret_cast<void *>(SbkVoidPtrObject_methods)},
+        {0, nullptr}
+    };
+
+    PyType_Spec SbkVoidPtrType_spec = {
+        "2:shiboken6.Shiboken.VoidPtr",
+        sizeof(SbkVoidPtrObject),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        SbkVoidPtrType_slots,
+    };
+
+    return SbkType_FromSpec_BMDWB(&SbkVoidPtrType_spec,
+                                  nullptr, nullptr, 0, 0,
+                                  &SbkVoidPtrObjectBufferProc);
 }
 
 PyTypeObject *SbkVoidPtr_TypeF(void)
 {
-    static PyTypeObject *type = SbkType_FromSpec_BMDWB(&SbkVoidPtrType_spec,
-                                                       nullptr, nullptr, 0, 0,
-                                                       &SbkVoidPtrObjectBufferProc);
+    static auto *type = createVoidPtrType();
     return type;
 }
 
+} // extern "C"
+
 namespace VoidPtr {
 
 static int voidPointerInitialized = false;
diff --git a/sources/shiboken6/shibokenmodule/CMakeLists.txt b/sources/shiboken6/shibokenmodule/CMakeLists.txt
index 1a3d42a1b..702750450 100644
--- a/sources/shiboken6/shibokenmodule/CMakeLists.txt
+++ b/sources/shiboken6/shibokenmodule/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(shibokenmodule)
 
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/shibokenmodule.txt.in"
@@ -25,9 +28,12 @@ add_custom_command(
 add_library(shibokenmodule MODULE ${sample_SRC})
 target_include_directories(shibokenmodule PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
                                                   ${CMAKE_SOURCE_DIR})
-set_property(TARGET shibokenmodule PROPERTY PREFIX "")
-# PYSIDE-1497: This `..` is the crucial trick to unify the path location of `Shiboken`.
-set_property(TARGET shibokenmodule PROPERTY OUTPUT_NAME "../Shiboken${PYTHON_EXTENSION_SUFFIX}")
+
+set_target_properties(shibokenmodule PROPERTIES
+                      PREFIX ""
+                      OUTPUT_NAME "Shiboken${PYTHON_EXTENSION_SUFFIX}"
+                      LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/.."
+                      RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/..")
 
 if(WIN32)
     set_property(TARGET shibokenmodule PROPERTY SUFFIX ".pyd")
diff --git a/sources/shiboken6/shibokenmodule/Shiboken.pyi b/sources/shiboken6/shibokenmodule/Shiboken.pyi
index a708e3871..6a1a63217 100644
--- a/sources/shiboken6/shibokenmodule/Shiboken.pyi
+++ b/sources/shiboken6/shibokenmodule/Shiboken.pyi
@@ -18,7 +18,8 @@ class Object(object):
     def __init__(self) -> None: ...
 
 
-class VoidPtr(object): ...
+class VoidPtr(object):
+    def __init__(self, value: int) -> None: ...
 
 
 def _unpickle_enum(arg__1: object, arg__2: object) -> object: ...
diff --git a/sources/shiboken6/shibokenmodule/_config.py.in b/sources/shiboken6/shibokenmodule/_config.py.in
index 92b3cd23c..600c431c9 100644
--- a/sources/shiboken6/shibokenmodule/_config.py.in
+++ b/sources/shiboken6/shibokenmodule/_config.py.in
@@ -9,3 +9,4 @@ version_info = (@shiboken_MAJOR_VERSION@, @shiboken_MINOR_VERSION@, @shiboken_MI
 @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/shiboken6/shibokenmodule/files.dir/shibokensupport/feature.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/feature.py
index 92bc30d2b..7a0871ee7 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/feature.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/feature.py
@@ -1,6 +1,9 @@
 # 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
 
+# flake8: noqa F:821
+# flake8: noqa F:401
+
 """
 __feature__.py  (renamed to feature.py)
 
@@ -15,9 +18,10 @@ The normal usage is like
 Alternatively, there is the `set_selection` function which uses select_id's
 and takes an optional `mod_name` parameter.
 
-The select id `-1` has the spectial meaning "ignore this module".
+The select id `-1` has the special meaning "ignore this module".
 """
 
+import inspect
 import sys
 from contextlib import contextmanager
 
@@ -79,11 +83,13 @@ None to indicate that a normal import should be performed, and
 All these variables are transparently kept in module `builtins`.
 """
 
+
 def feature_import(name, *args, **kwargs):
     # PYSIDE-1368: The `__name__` attribute does not need to exist in all modules.
     # PYSIDE-1398: sys._getframe(1) may not exist when embedding.
     # PYSIDE-1338: The "1" below is the redirection in loader.py .
     # PYSIDE-1548: Ensure that features are not affected by other imports.
+    # PYSIDE-2029: Need to always switch. The cache was wrong interpreted.
     calling_frame = _cf = sys._getframe(1).f_back
     importing_module = _cf.f_globals.get("__name__", "__main__") if _cf else "__main__"
     existing = pyside_feature_dict.get(importing_module, 0)
@@ -105,27 +111,68 @@ def feature_import(name, *args, **kwargs):
         # Initialize feature (multiple times allowed) and clear cache.
         sys.modules["PySide6.QtCore"].__init_feature__()
         return sys.modules["__feature__"]
-
-    if importing_module not in pyside_feature_dict:
-        # Ignore new modules if not from PySide.
-        default = 0 if name.split(".")[0] == "PySide6" else -1
-        pyside_feature_dict[importing_module] = default
     # Redirect to the original import
     return None
 
+
 _is_initialized = False
 
+
 def __init__():
     global _is_initialized
     if not _is_initialized:
         # use _one_ recursive import...
         import PySide6.QtCore
         # Initialize all prior imported modules
-        for name in sys.modules:
-            pyside_feature_dict.setdefault(name, -1)
+        for name, module in sys.modules.items():
+            if name not in pyside_feature_dict:
+                pyside_feature_dict[name] = 0 if _mod_uses_pyside(module) else -1
         _is_initialized = True
 
 
+def feature_imported(module):
+    # PYSIDE-2029: Need to inspect imported modules for PySide usage.
+    """
+    Set the module feature default after import.
+
+    A module that uses PySide has a switching default of 0 = "no feature".
+    Otherwise the default is -1 = "ignore this module".
+    """
+
+    # PYSIDE-1368: The `__name__` attribute does not need to exist in all modules.
+    if hasattr(module, "__name__"):
+        name = module.__name__
+        if name not in pyside_feature_dict:
+            pyside_feature_dict[name] = 0 if _mod_uses_pyside(module) else -1
+
+
+def _mod_uses_pyside(module):
+    """
+    Find out if this module uses PySide.
+
+    Simple approach: Search the source code for the string "PySide6".
+    Maybe we later support source-less modules by inspecting all code objects.
+    """
+    try:
+        source = inspect.getsource(module)
+    except TypeError:
+        # this is a builtin module like sys
+        return False
+    except OSError:
+        # this is a module withot source file
+        return False
+    except SyntaxError:
+        # PYSIDE-2189: A UnicodeError happens in tokenize.py in find_cookie
+        #              which is then creating a SyntaxError in inspect.
+        # This is undocumented and a Python error, seen in Python 3.10.2 on Windows,
+        # importing `pythoncom` of the win32 package.
+        return False
+    except Exception:
+        # PYSIDE-2393: pytest behaves weird when allowing any other error.
+        return False
+    return "PySide6" in source
+
+
 def set_selection(select_id, mod_name=None):
     """
     Internal use: Set the feature directly by Id.
@@ -141,6 +188,7 @@ def set_selection(select_id, mod_name=None):
     sys.modules["PySide6.QtCore"].__init_feature__()
     return _current_selection(flag)
 
+
 # The set_section(0) case seems to be unsafe. We will migrate to
 # use the opaque feature.reset() call in all test cases.
 def reset():
diff --git a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/fix-complaints.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/fix-complaints.py
index 3e1d49328..f7190b12f 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/fix-complaints.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/fix-complaints.py
@@ -9,7 +9,6 @@ Run it once after copying a new version. It is idem-potent, unless
 you are changing messages (what I did, of course :-) .
 """
 
-import os
 import glob
 from pathlib import Path
 
@@ -24,6 +23,7 @@ offending_words = {
 utf8_line = "# This Python file uses the following encoding: utf-8\n"
 marker_line = f"# It has been edited by {Path(__file__).name} .\n"
 
+
 def patch_file(fname):
     with fname.open() as f:
         lines = f.readlines()
@@ -41,6 +41,7 @@ def patch_file(fname):
         with open(fname, "w") as f:
             f.write("".join(lines))
 
+
 def doit():
     dirname = Path(__file__).parent
     patched_files = []
@@ -51,6 +52,7 @@ def doit():
         print("Working on", fname)
         patch_file(fname)
 
+
 if __name__ == "__main__":
     doit()
 
diff --git a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/errorhandler.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/errorhandler.py
index 6b428e613..c2a19efef 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/errorhandler.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/errorhandler.py
@@ -1,6 +1,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
 
+# flake8: noqa E:721
+
 """
 errorhandler.py
 
@@ -19,12 +21,10 @@ This matter will be improved in a later version.
 """
 
 import collections.abc
-import inspect
-import sys
 import typing
 
 from shibokensupport.signature import get_signature
-from shibokensupport.signature.mapping import update_mapping, namespace
+from shibokensupport.signature.mapping import namespace
 from textwrap import dedent
 
 
@@ -77,8 +77,8 @@ def seterror_argument(args, func_name, info):
         if info == "<":
             msg = f"{func_name}(): not enough arguments"
         elif info == "0":
-           msg = (f"{func_name}(): not enough arguments. "
-                  "Note: keyword arguments are only supported for optional parameters.")
+            msg = (f"{func_name}(): not enough arguments. "
+                   "Note: keyword arguments are only supported for optional parameters.")
         elif info == ">":
             msg = f"{func_name}(): too many arguments"
         elif info.isalnum():
@@ -87,6 +87,12 @@ def seterror_argument(args, func_name, info):
             msg = f"{func_name}(): {info}"
             err = AttributeError
         return err, msg
+    if isinstance(info, Exception):
+        # PYSIDE-2230: Python 3.12 seems to always do normalization.
+        err = type(info)
+        info = info.args[0]
+        msg = f"{func_name}(): {info}"
+        return err, msg
     if info and type(info) is dict:
         msg = f"{func_name}(): unsupported keyword '{tuple(info)[0]}'"
         return AttributeError, msg
@@ -126,6 +132,8 @@ def check_string_type(s):
 
 def make_helptext(func):
     existing_doc = func.__doc__
+    if existing_doc is None and hasattr(func, "__dict__"):
+        existing_doc = func.__dict__.get("__doc__")
     sigs = get_signature(func)
     if not sigs:
         return existing_doc
diff --git a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/importhandler.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/importhandler.py
index dbde18f18..bae264294 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/importhandler.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/importhandler.py
@@ -34,9 +34,10 @@ def finish_import(module):
         except Exception as e:
             name = e.__class__.__qualname__
             print(72 * "*")
-            print(f"Error in deprecated.py, ignored:")
+            print("Error in deprecated.py, ignored:")
             print(f"    {name}: {e}")
 
+
 """
 A note for people who might think this could be written in pure Python:
 
@@ -62,4 +63,3 @@ module, it is *perhaps* possible to solve that. I tried for a day and then
 gave up, since the solution is anyway not too nice when __import__ must
 be overridden.
 """
-#eof
diff --git a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/layout.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/layout.py
index c271be7f7..0e781cbcb 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/layout.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/layout.py
@@ -79,6 +79,7 @@ class SignatureLayout(SimpleNamespace):
             The only allowed values are '{allowed_values}'.
             """))
 
+
 # The following names are used literally in this module.
 # This way, we avoid the dict hashing problem.
 signature = SignatureLayout()
@@ -115,7 +116,7 @@ def define_nameless_parameter():
     P = inspect.Parameter
     newname = "NamelessParameter"
     bases = P.__bases__
-    body = dict(P.__dict__) # get rid of mappingproxy
+    body = dict(P.__dict__)  # get rid of mappingproxy
     if "__slots__" in body:
         # __slots__ would create duplicates
         for name in body["__slots__"]:
@@ -167,12 +168,13 @@ def make_signature_nameless(signature):
         signature.parameters[key].__class__ = NamelessParameter
 
 
-_POSITIONAL_ONLY         = inspect._POSITIONAL_ONLY
-_POSITIONAL_OR_KEYWORD   = inspect._POSITIONAL_OR_KEYWORD
-_VAR_POSITIONAL          = inspect._VAR_POSITIONAL
-_KEYWORD_ONLY            = inspect._KEYWORD_ONLY
-_VAR_KEYWORD             = inspect._VAR_KEYWORD
-_empty                   = inspect._empty
+_POSITIONAL_ONLY         = inspect._POSITIONAL_ONLY  # noqa E:201
+_POSITIONAL_OR_KEYWORD   = inspect._POSITIONAL_OR_KEYWORD  # noqa E:201
+_VAR_POSITIONAL          = inspect._VAR_POSITIONAL  # noqa E:201
+_KEYWORD_ONLY            = inspect._KEYWORD_ONLY  # noqa E:201
+_VAR_KEYWORD             = inspect._VAR_KEYWORD  # noqa E:201
+_empty                   = inspect._empty  # noqa E:201
+
 
 def create_signature(props, key):
     if not props:
@@ -183,9 +185,9 @@ def create_signature(props, key):
         return list(create_signature(elem, key)
                     for elem in props["multi"])
     if type(key) is tuple:
-        sig_kind, modifier = key
+        _, modifier = key
     else:
-        sig_kind, modifier = key, "signature"
+        _, modifier = key, "signature"
 
     layout = globals()[modifier]  # lookup of the modifier in this module
     if not isinstance(layout, SignatureLayout):
@@ -234,8 +236,8 @@ def create_signature(props, key):
         if kind == _VAR_POSITIONAL:
             kind = _KEYWORD_ONLY
     sig = inspect.Signature(params,
-           return_annotation=annotations.get('return', _empty),
-           __validate_parameters__=False)
+                            return_annotation=annotations.get('return', _empty),
+                            __validate_parameters__=False)
 
     # the special case of nameless parameters
     if not layout.parameter_names:
diff --git a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py
index 947537a0f..5650e2bc1 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py
@@ -14,9 +14,7 @@ by producing a lot of clarity.
 import inspect
 import sys
 import types
-import typing
 from shibokensupport.signature import get_signature as get_sig
-from shibokensupport.signature.layout import create_signature
 
 
 """
@@ -106,7 +104,7 @@ class ExactEnumerator(object):
             return ret
         if "<" in class_name:
             # This is happening in QtQuick for some reason:
-            ## class QSharedPointer<QQuickItemGrabResult >:
+            # class std::shared_ptr<QQuickItemGrabResult >:
             # We simply skip over this class.
             return ret
         bases_list = []
@@ -125,11 +123,18 @@ class ExactEnumerator(object):
         enums = []
         properties = []
         signals = []
+        attributes = {}
 
         for thing_name, thing in class_members:
             if signal_check(thing):
                 signals.append((thing_name, thing))
             elif inspect.isclass(thing):
+                # If this is the only member of the class, it causes the stub
+                # to be printed empty without ..., as self.fmt.have_body will
+                # then be True. (Example: QtCore.QCborTag). Skip it to avoid
+                # this problem.
+                if thing_name == "_member_type_":
+                    continue
                 subclass_name = ".".join((class_name, thing_name))
                 subclasses.append((subclass_name, thing))
             elif inspect.isroutine(thing):
@@ -141,21 +146,28 @@ class ExactEnumerator(object):
                     enums.append((thing_name, type(thing).__qualname__, thing))
             elif isinstance(thing, property):
                 properties.append((thing_name, thing))
+            # Support attributes that have PySide types as values,
+            # but we skip the 'staticMetaObject' that needs
+            # to be defined at a QObject level.
+            elif "PySide" in str(type(thing)) and "QMetaObject" not in str(type(thing)):
+                if class_name not in attributes:
+                    attributes[class_name] = {}
+                attributes[class_name][thing_name] = thing
 
             if thing_name in self.collision_candidates:
                 self.collision_track.add(thing_name)
 
         init_signature = getattr(klass, "__signature__", None)
-        new_enum = sys.pyside63_option_python_enum
         # sort by class then enum value
-        enums.sort(key=lambda tup: (tup[1], tup[2].value if new_enum else tup[2]))
+        enums.sort(key=lambda tup: (tup[1], tup[2].value))
 
         # We want to handle functions and properties together.
         func_prop = sorted(functions + properties, key=lambda tup: tup[0])
 
         # find out how many functions create a signature
         sigs = list(_ for _ in functions if get_sig(_[1]))
-        self.fmt.have_body = bool(subclasses or sigs or properties or enums or init_signature)
+        self.fmt.have_body = bool(subclasses or sigs or properties or enums or  # noqa W:504
+                                  init_signature or signals or attributes)
 
         with self.fmt.klass(class_name, class_str):
             self.fmt.level += 1
@@ -165,8 +177,7 @@ class ExactEnumerator(object):
                 if len(enums):
                     self.section()
                 for enum_name, enum_class_name, value in enums:
-                    with self.fmt.enum(enum_class_name, enum_name,
-                                       value.value if new_enum else value):
+                    with self.fmt.enum(enum_class_name, enum_name, value.value):
                         pass
             if hasattr(self.fmt, "signal"):
                 # this is an optional feature
@@ -178,6 +189,13 @@ class ExactEnumerator(object):
                     sig_str = str(signal)
                     with self.fmt.signal(sig_class_name, signal_name, sig_str):
                         pass
+            if hasattr(self.fmt, "attribute"):
+                if len(attributes):
+                    self.section()
+                for class_name, attrs in attributes.items():
+                    for attr_name, attr_value in attrs.items():
+                        with self.fmt.attribute(attr_name, attr_value):
+                            pass
             if len(subclasses):
                 self.section()
             for subclass_name, subclass in subclasses:
diff --git a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/pyi_generator.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/pyi_generator.py
index bbca35fbd..ce12dd6c8 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/pyi_generator.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/pyi_generator.py
@@ -3,6 +3,8 @@ LICENSE_TEXT = """
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 """
 
+# flake8: noqa E:402
+
 """
 pyi_generator.py
 
@@ -21,7 +23,6 @@ from pathlib import Path
 from contextlib import contextmanager
 from textwrap import dedent
 
-from shiboken6 import Shiboken
 from shibokensupport.signature.lib.enum_sig import HintingEnumerator
 from shibokensupport.signature.lib.tool import build_brace_pattern
 
@@ -59,6 +60,7 @@ class Formatter(Writer):
     unrelated tasks of enumeration and formatting apart.
     """
     def __init__(self, outfile, options, *args):
+        # XXX Find out which of these patches is still necessary!
         self.options = options
         Writer.__init__(self, outfile, *args)
         # patching __repr__ to disable the __repr__ of typing.TypeVar:
@@ -74,8 +76,12 @@ class Formatter(Writer):
         """
         def _typevar__repr__(self):
             return f"typing.{self.__name__}"
-        typing.TypeVar.__repr__ = _typevar__repr__
-
+        # This is no longer necessary for modern typing versions.
+        # Ignore therefore if the repr is read-only and cannot be changed.
+        try:
+            typing.TypeVar.__repr__ = _typevar__repr__
+        except TypeError:
+            pass
         # Adding a pattern to substitute "Union[T, NoneType]" by "Optional[T]"
         # I tried hard to replace typing.Optional by a simple override, but
         # this became _way_ too much.
@@ -84,6 +90,7 @@ class Formatter(Writer):
         pattern = fr"\b Union \s* \[ \s* {brace_pat} \s*, \s* NoneType \s* \]"
         replace = r"Optional[\1]"
         optional_searcher = re.compile(pattern, flags=re.VERBOSE)
+
         def optional_replacer(source):
             return optional_searcher.sub(replace, str(source))
         self.optional_replacer = optional_replacer
@@ -152,6 +159,12 @@ class Formatter(Writer):
         yield
 
     @contextmanager
+    def attribute(self, attr_name, attr_value):
+        spaces = indent * self.level
+        self.print(f"{spaces}{attr_name:25} = ...  # type: {type(attr_value).__qualname__}")
+        yield
+
+    @contextmanager
     def signal(self, class_name, sig_name, sig_str):
         spaces = indent * self.level
         self.print(f"{spaces}{sig_name:25}: ClassVar[{class_name}] = ... # {sig_str}")
@@ -165,12 +178,14 @@ def find_imports(text):
 FROM_IMPORTS = [
     (None, ["builtins"]),
     (None, ["os"]),
-    (None, ["enum"] if sys.pyside63_option_python_enum else []),
+    (None, ["enum"]),
+    ("collections.abc", ["Iterable"]),
     ("typing", sorted(typing.__all__)),
     ("PySide6.QtCore", ["PyClassProperty", "Signal", "SignalInstance"]),
     ("shiboken6", ["Shiboken"]),
     ]
 
+
 def filter_from_imports(from_struct, text):
     """
     Build a reduced new `from` structure (nfs) with found entries, only
@@ -180,8 +195,15 @@ def filter_from_imports(from_struct, text):
         lis = []
         nfs.append((mod, lis))
         for each in imports:
-            if re.search(rf"(\b|@){each}\b([^\s\(:]|\n)", text):
-                lis.append(each)
+            # PYSIDE-1603: We search text that is a usage of the class `each`,
+            #              but only if the class is not also defined here.
+            if (f"class {each}(") not in text:
+                if re.search(rf"(\b|@){each}\b([^\s\(:]|\n)", text):
+                    lis.append(each)
+                # Search if a type is present in the return statement
+                # of function declarations: '... -> here:'
+                if re.search(rf"->.*{each}.*:", text):
+                    lis.append(each)
         if not lis:
             nfs.pop()
     return nfs
@@ -220,12 +242,10 @@ def generate_pyi(import_name, outpath, options):
     obj = getattr(top, plainname) if import_name != plainname else top
     if not getattr(obj, "__file__", None) or Path(obj.__file__).is_dir():
         raise ModuleNotFoundError(f"We do not accept a namespace as module `{plainname}`")
-    module = sys.modules[import_name]
 
     outfile = io.StringIO()
     fmt = Formatter(outfile, options)
     fmt.print(LICENSE_TEXT.strip())
-    need_imports = options._pyside_call and not USE_PEP563
     if USE_PEP563:
         fmt.print("from __future__ import annotations")
         fmt.print()
@@ -267,13 +287,12 @@ def generate_pyi(import_name, outpath, options):
                         wr.print(f"from {mod} import {import_args}")
                 wr.print()
                 wr.print()
+                wr.print("NoneType: TypeAlias = type[None]")
+                wr.print()
             else:
                 wr.print(line)
     if not options.quiet:
         options.logger.info(f"Generated: {outfilepath}")
-    # PYSIDE-1735: .pyi files are no longer compatible with Python, because
-    #              enum classes contain ellipsis which a Python enum forbids.
-    #              We will implement tests with Mypy, instead.
 
 
 def main():
@@ -288,11 +307,10 @@ def main():
             pyi_generator will try to generate an interface "<module>.pyi".
             """))
     parser.add_argument("module",
-        help="The full path name of an importable module binary (.pyd, .so)")
+        help="The full path name of an importable module binary (.pyd, .so)")  # noqa E:128
     parser.add_argument("--quiet", action="store_true", help="Run quietly")
-    parser.add_argument("--check", action="store_true", help="Test the output")
     parser.add_argument("--outpath",
-        help="the output directory (default = location of module binary)")
+        help="the output directory (default = location of module binary)")  # noqa E:128
     options = parser.parse_args()
     module = options.module
     outpath = options.outpath
@@ -310,6 +328,7 @@ def main():
     options.logger = logger
     generate_pyi(module, outpath, options=options)
 
+
 if __name__ == "__main__":
     main()
 # eof
diff --git a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/tool.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/tool.py
index a7900e6b2..979dcf4ce 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/tool.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/tool.py
@@ -44,8 +44,8 @@ def build_brace_pattern(level, separators):
 
     ro, rc = round_ = "()"
     so, sc = square = "[]"
-    co, cc = curly  = "CD"      # we insert "{}", later...
-    ao, ac = angle  = "<>"
+    co, cc = curly  = "CD"  # noqa E:201 we insert "{}", later...
+    ao, ac = angle  = "<>"  # noqa E:201
     q2, bs, q1 = '"', "\\", "'"
     allpat = round_ + square + curly + angle
     __ = "  "
@@ -79,8 +79,8 @@ def build_brace_pattern(level, separators):
         {indent}  )*
         """)
     for idx in range(level):
-        pattern = pattern.format(replacer = repeated if idx < level-1 else no_braces_q,
-                                 indent = idx * "    ", **locals())
+        pattern = pattern.format(replacer=repeated if idx < level - 1 else no_braces_q,
+                                 indent=idx * "    ", **locals())
     return pattern.replace("C", "{").replace("D", "}")
 
 
diff --git a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/loader.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/loader.py
index 34977f3bd..fb4c9eeca 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/loader.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/loader.py
@@ -1,6 +1,9 @@
 # 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
 
+# flake8: noqa E:402
+# flake8: noqa F:401
+
 """
 loader.py
 
@@ -30,22 +33,27 @@ import types
 def pyside_type_init(type_key, sig_strings):
     return parser.pyside_type_init(type_key, sig_strings)
 
+
 # name used in signature.cpp
 def create_signature(props, key):
     return layout.create_signature(props, key)
 
+
 # name used in signature.cpp
 def seterror_argument(args, func_name, info):
     return errorhandler.seterror_argument(args, func_name, info)
 
+
 # name used in signature.cpp
 def make_helptext(func):
     return errorhandler.make_helptext(func)
 
+
 # name used in signature.cpp
 def finish_import(module):
     return importhandler.finish_import(module)
 
+
 # name used in signature.cpp
 def feature_import(*args, **kwds):
     # don't spend a stack level here for speed and compatibility
@@ -54,6 +62,14 @@ def feature_import(*args, **kwds):
     return feature_import(*args, **kwds)
 
 
+# name used in signature.cpp
+def feature_imported(*args, **kwds):
+    # don't spend a stack level here for speed and compatibility
+    global feature_imported
+    feature_imported = feature.feature_imported
+    return feature_imported(*args, **kwds)
+
+
 import builtins
 import signature_bootstrap
 from shibokensupport import signature, feature
@@ -100,6 +116,7 @@ def move_into_pyside_package():
     put_into_package(PySide6.support.signature.lib, pyi_generator)
     put_into_package(PySide6.support.signature.lib, tool)
 
+
 from shibokensupport.signature import mapping
 from shibokensupport.signature import errorhandler
 from shibokensupport.signature import layout
@@ -112,23 +129,30 @@ from shibokensupport.signature.lib import tool
 
 import enum
 
+post_init = lambda: None  # noqa E:731 default
+
 if "PySide6" in sys.modules:
     # We publish everything under "PySide6.support", again.
     move_into_pyside_package()
     # PYSIDE-1502: Make sure that support can be imported.
     try:
         import PySide6.support
-    except ModuleNotFoundError as e:
+    except ModuleNotFoundError:
         print("PySide6.support could not be imported. "
               "This is a serious configuration error.", file=sys.stderr)
         raise
-    # PYSIDE-1019: Modify `__import__` to be `__feature__` aware.
-    # __feature__ is already in sys.modules as feature, so this is actually no import
-    if not is_pypy:
-        # PYSIDE-535: Cannot enable __feature__ for various reasons.
-        import PySide6.support.feature
-        sys.modules["__feature__"] = PySide6.support.feature
-        builtins.__orig_import__ = builtins.__import__
-        builtins.__import__ = builtins.__feature_import__
+
+    def post_init():
+        """
+        This function needs to be called explicitly when all function pointers are set.
+        Doing this during import has bad side-effects when preloading the loader.
+        """
+        # PYSIDE-1019: Modify `__import__` to be `__feature__` aware.
+        if not is_pypy:
+            # PYSIDE-535: Cannot enable __feature__ for various reasons.
+            import PySide6.support.feature
+            sys.modules["__feature__"] = PySide6.support.feature
+            builtins.__orig_import__ = builtins.__import__
+            builtins.__import__ = builtins.__feature_import__
 
 # end of file
diff --git a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/mapping.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/mapping.py
index dbc4596a2..944a928e6 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/mapping.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/mapping.py
@@ -1,6 +1,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
 
+# flake8: noqa E:203
+
 """
 mapping.py
 
@@ -20,10 +22,12 @@ from pathlib import Path
 from typing import TypeVar, Generic
 from _imp import is_builtin
 
+
 class ellipsis(object):
     def __repr__(self):
         return "..."
 
+
 ellipsis = ellipsis()
 Point = typing.Tuple[int, int]
 Variant = typing.Any
@@ -38,7 +42,7 @@ _S = TypeVar("_S")
 MultiMap = typing.DefaultDict[str, typing.List[str]]
 
 # ulong_max is only 32 bit on windows.
-ulong_max = 2*sys.maxsize+1 if len(struct.pack("L", 1)) != 4 else 0xffffffff
+ulong_max = 2 * sys.maxsize + 1 if len(struct.pack("L", 1)) != 4 else 0xffffffff
 ushort_max = 0xffff
 
 GL_COLOR_BUFFER_BIT = 0x00004000
@@ -74,6 +78,7 @@ class _NotCalled(str):
         text = self if self.endswith(")") else self + "()"
         return eval(text, namespace)
 
+
 USE_PEP563 = False
 # Note: we cannot know if this feature has been imported.
 # Otherwise it would be "sys.version_info[:2] >= (3, 7)".
@@ -86,6 +91,7 @@ USE_PEP563 = False
 class Virtual(_NotCalled):
     pass
 
+
 # Other types I simply could not find.
 class Missing(_NotCalled):
     # The string must be quoted, because the object does not exist.
@@ -98,6 +104,7 @@ class Missing(_NotCalled):
 class Invalid(_NotCalled):
     pass
 
+
 # Helper types
 class Default(_NotCalled):
     pass
@@ -106,6 +113,7 @@ class Default(_NotCalled):
 class Instance(_NotCalled):
     pass
 
+
 # Parameterized primitive variables
 class _Parameterized(object):
     def __init__(self, type):
@@ -115,15 +123,18 @@ class _Parameterized(object):
     def __repr__(self):
         return f"{type(self).__name__}({self.type.__name__})"
 
+
 # Mark the primitive variables to be moved into the result.
 class ResultVariable(_Parameterized):
     pass
 
+
 # Mark the primitive variables to become Sequence, Iterable or List
 # (decided in the parser).
 class ArrayLikeVariable(_Parameterized):
     pass
 
+
 StringList = ArrayLikeVariable(str)
 
 
@@ -142,7 +153,7 @@ class Reloader(object):
         if getattr(mod, "__file__", None) and not Path(mod.__file__).is_dir():
             ending = Path(mod.__file__).suffix
             return ending not in (".py", ".pyc", ".pyo", ".pyi")
-        return bool(is_builtin(mod.__name__))
+        return bool(hasattr(mod, "__name__") and is_builtin(mod.__name__))
 
     def update(self):
         """
@@ -180,12 +191,14 @@ def check_module(mod):
         mod_name = mod.__name__
         raise ImportError(f"Module '{mod_name}' is not a binary module!")
 
+
 update_mapping = Reloader().update
 type_map = {}
 namespace = globals()  # our module's __dict__
 
 type_map.update({
     "...": ellipsis,
+    "Any": typing.Any,
     "bool": bool,
     "char": int,
     "double": float,
@@ -200,7 +213,7 @@ type_map.update({
     "PyObject": object,
     "PyObject*": object,
     "PyArrayObject": ArrayLikeVariable, # numpy
-    "PyPathLike": typing.Union[str, bytes, os.PathLike],
+    "PyPathLike": typing.Union[str, bytes, os.PathLike[str]],
     "PySequence": typing.Iterable,  # important for numpy
     "PyTypeObject": type,
     "QChar": str,
@@ -217,6 +230,7 @@ type_map.update({
     "uintptr_t": int,
     "qintptr": int,
     "qsizetype": int,
+    "QFunctionPointer": int,
     "QList": ArrayLikeVariable,
     "qlonglong": int,
     "QMap": typing.Dict,
@@ -227,6 +241,7 @@ type_map.update({
     "qreal": float,
     "QSet": typing.Set,
     "QString": str,
+    "QLatin1String": str,
     "QStringView": str,
     "QStringList": StringList,
     "quint16": int,
@@ -264,16 +279,16 @@ type_map.update({
     "ulong": int,
     "ULONG_MAX": ulong_max,
     "UINT64_MAX": 0xffffffff,
-    "unsigned char": int, # 5.9
+    "unsigned char": int,  # 5.9
     "unsigned char*": str,
     "unsigned int": int,
-    "unsigned long int": int, # 5.6, RHEL 6.6
+    "unsigned long int": int,  # 5.6, RHEL 6.6
     "unsigned long long": int,
     "unsigned long": int,
-    "unsigned short int": int, # 5.6, RHEL 6.6
+    "unsigned short int": int,  # 5.6, RHEL 6.6
     "unsigned short": int,
     "ushort": int,
-    "void": int, # be more specific?
+    "void": int,  # be more specific?
     "WId": WId,
     "zero(bytes)": b"",
     "zero(Char)": 0,
@@ -285,7 +300,9 @@ type_map.update({
     "zero(Any)": None,
     # This can be refined by importing numpy.typing optionally, but better than nothing.
     "numpy.ndarray": typing.List[typing.Any],
-    })
+    "std.array[int, 4]": typing.List[int],
+    "std.array[float, 4]": typing.List[float]
+})
 
 type_map.update({
     # Handling variables declared as array:
@@ -297,8 +314,8 @@ type_map.update({
     "array long long*"      : ArrayLikeVariable(int),
     "array long*"           : ArrayLikeVariable(int),
     "array short*"          : ArrayLikeVariable(int),
-    "array signed char*"    : bytes,
-    "array unsigned char*"  : bytes,
+    "array signed char*"    : typing.Union[bytes, bytearray, memoryview],
+    "array unsigned char*"  : typing.Union[bytes, bytearray, memoryview],
     "array unsigned int*"   : ArrayLikeVariable(int),
     "array unsigned short*" : ArrayLikeVariable(int),
     # PYSIDE-1646: New macOS primitive types
@@ -309,17 +326,17 @@ type_map.update({
     "array int32_t*"        : ArrayLikeVariable(int),
     "array uint32_t*"       : ArrayLikeVariable(int),
     "array intptr_t*"       : ArrayLikeVariable(int),
-    })
+})
 
 type_map.update({
     # Special cases:
-    "char*"         : bytes,
-    "QChar*"        : bytes,
+    "char*"         : typing.Union[bytes, bytearray, memoryview],
+    "QChar*"        : typing.Union[bytes, bytearray, memoryview],
     "quint32*"      : int,        # only for QRandomGenerator
     "quint8*"       : bytearray,  # only for QCborStreamReader and QCborValue
-    "uchar*"        : bytes,
-    "unsigned char*": bytes,
-    })
+    "uchar*"        : typing.Union[bytes, bytearray, memoryview],
+    "unsigned char*": typing.Union[bytes, bytearray, memoryview],
+})
 
 type_map.update({
     # Handling variables that are returned, eventually as Tuples:
@@ -341,7 +358,7 @@ type_map.update({
     "uint*"         : ResultVariable(int),
     "unsigned int*" : ResultVariable(int),
     "QStringList*"  : ResultVariable(StringList),
-    })
+})
 
 
 type_map.update({
@@ -349,20 +366,21 @@ type_map.update({
     "[typing.Any]"  : [typing.Any],
     "[typing.Any,typing.Any]"  : [typing.Any, typing.Any],
     "None" : None,
-    })
+})
 
 
 # PYSIDE-1328: We need to handle "self" explicitly.
 type_map.update({
     "self" : "self",
     "cls"  : "cls",
-    })
+})
 
 # PYSIDE-1538: We need to treat "std::optional" accordingly.
 type_map.update({
     "std.optional": typing.Optional,
     })
 
+
 # The Shiboken Part
 def init_Shiboken():
     type_map.update({
@@ -372,6 +390,7 @@ def init_Shiboken():
     })
     return locals()
 
+
 def init_minimal():
     type_map.update({
         "MinBool": bool,
@@ -387,7 +406,7 @@ def init_sample():
         "const char*": str,
         "Complex": complex,
         "double": float,
-        "ByteArray&": bytes,
+        "ByteArray&": typing.Union[bytes, bytearray, memoryview],
         "Foo.HANDLE": int,
         "HANDLE": int,
         "Null": None,
@@ -395,7 +414,7 @@ def init_sample():
         "OddBool": bool,
         "PStr": str,
         "PyDate": datetime.date,
-        "PyBuffer": bytes,
+        "PyBuffer": typing.Union[bytes, bytearray, memoryview],
         "sample.bool": bool,
         "sample.char": int,
         "sample.double": float,
@@ -431,6 +450,7 @@ def init_smart():
     # This missing type should be defined in module smart. We cannot set it to Missing()
     # because it is a container type. Therefore, we supply a surrogate:
     global SharedPtr
+
     class SharedPtr(Generic[_S]):
         __module__ = "smart"
     smart.SharedPtr = SharedPtr
@@ -444,7 +464,7 @@ def init_smart():
 def init_PySide6_QtCore():
     from PySide6.QtCore import Qt, QUrl, QDir, QKeyCombination
     from PySide6.QtCore import QRect, QRectF, QSize, QPoint, QLocale, QByteArray
-    from PySide6.QtCore import QMarginsF # 5.9
+    from PySide6.QtCore import QMarginsF  # 5.9
     from PySide6.QtCore import SignalInstance
     try:
         # seems to be not generated by 5.9 ATM.
@@ -455,40 +475,41 @@ def init_PySide6_QtCore():
         "' '": " ",
         "'%'": "%",
         "'g'": "g",
-        "4294967295UL": 4294967295, # 5.6, RHEL 6.6
+        "4294967295UL": 4294967295,  # 5.6, RHEL 6.6
         "CheckIndexOption.NoOption": Instance(
-            "PySide6.QtCore.QAbstractItemModel.CheckIndexOptions.NoOption"), # 5.11
+            "PySide6.QtCore.QAbstractItemModel.CheckIndexOptions.NoOption"),  # 5.11
         "DescriptorType(-1)": int,  # Native handle of QSocketDescriptor
         "false": False,
         "list of QAbstractAnimation": typing.List[PySide6.QtCore.QAbstractAnimation],
         "long long": int,
         "size_t": int,
-        "NULL": None, # 5.6, MSVC
-        "nullptr": None, # 5.9
-        "PyBuffer": bytes,
+        "NULL": None,  # 5.6, MSVC
+        "nullptr": None,  # 5.9
+        "PyBuffer": typing.Union[bytes, bytearray, memoryview],
         "PyByteArray": bytearray,
-        "PyBytes": bytes,
+        "PyBytes": typing.Union[bytes, bytearray, memoryview],
         "PyTuple": typing.Tuple,
         "QDeadlineTimer(QDeadlineTimer.Forever)": Instance("PySide6.QtCore.QDeadlineTimer"),
         "PySide6.QtCore.QUrl.ComponentFormattingOptions":
-            PySide6.QtCore.QUrl.ComponentFormattingOption, # mismatch option/enum, why???
+            PySide6.QtCore.QUrl.ComponentFormattingOption,  # mismatch option/enum, why???
         "PyUnicode": typing.Text,
         "QByteArrayView": QByteArray,
         "Q_NULLPTR": None,
         "QCalendar.Unspecified": PySide6.QtCore.QCalendar.Unspecified,
+        "QCborTag(-1)": ulong_max,
         "QDir.Filters(AllEntries | NoDotAndDotDot)": Instance(
             "QDir.Filters(QDir.AllEntries | QDir.NoDotAndDotDot)"),
         "QDir.SortFlags(Name | IgnoreCase)": Instance(
             "QDir.SortFlags(QDir.Name | QDir.IgnoreCase)"),
-        "QEvent.Type.None" : None,
-        "QGenericArgument((0))": ellipsis, # 5.6, RHEL 6.6. Is that ok?
+        "QEvent.Type.None": None,
+        "QGenericArgument((0))": ellipsis,  # 5.6, RHEL 6.6. Is that ok?
         "QGenericArgument()": ellipsis,
         "QGenericArgument(0)": ellipsis,
-        "QGenericArgument(NULL)": ellipsis, # 5.6, MSVC
-        "QGenericArgument(nullptr)": ellipsis, # 5.10
+        "QGenericArgument(NULL)": ellipsis,  # 5.6, MSVC
+        "QGenericArgument(nullptr)": ellipsis,  # 5.10
         "QGenericArgument(Q_NULLPTR)": ellipsis,
         "QJsonObject": typing.Dict[str, PySide6.QtCore.QJsonValue],
-        "QModelIndex()": Invalid("PySide6.QtCore.QModelIndex"), # repr is btw. very wrong, fix it?!
+        "QModelIndex()": Invalid("PySide6.QtCore.QModelIndex"),  # repr is btw. very wrong, fix it?!
         "QModelIndexList": typing.List[PySide6.QtCore.QModelIndex],
         "PySideSignalInstance": SignalInstance,
         "QString()": "",
@@ -496,17 +517,17 @@ def init_PySide6_QtCore():
         "QStringList()": [],
         "QStringRef": str,
         "QStringRef": str,
-        "Qt.HANDLE": int, # be more explicit with some constants?
+        "Qt.HANDLE": int,  # be more explicit with some constants?
         "QUrl.FormattingOptions(PrettyDecoded)": Instance(
             "QUrl.FormattingOptions(QUrl.PrettyDecoded)"),
         "QVariant()": Invalid(Variant),
-        "QVariant.Type": type, # not so sure here...
-        "QVariantMap": typing.Dict[str, Variant],
+        "QVariant.Type": type,  # not so sure here...
         "QVariantMap": typing.Dict[str, Variant],
+        "std.chrono.seconds{5}" : ellipsis,
     })
     try:
         type_map.update({
-            "PySide6.QtCore.QMetaObject.Connection": PySide6.QtCore.Connection, # wrong!
+            "PySide6.QtCore.QMetaObject.Connection": PySide6.QtCore.Connection,  # wrong!
         })
     except AttributeError:
         # this does not exist on 5.9 ATM.
@@ -531,7 +552,7 @@ def init_PySide6_QtConcurrent():
 
 
 def init_PySide6_QtGui():
-    from PySide6.QtGui import QPageLayout, QPageSize # 5.12 macOS
+    from PySide6.QtGui import QPageLayout, QPageSize  # 5.12 macOS
     type_map.update({
         "0.0f": 0.0,
         "1.0f": 1.0,
@@ -540,10 +561,11 @@ def init_PySide6_QtGui():
         "int32_t": int,
         "HBITMAP": int,
         "HICON": int,
+        "HMONITOR": int,
         "HRGN": int,
-        "QPixmap()": Default("PySide6.QtGui.QPixmap"), # can't create without qApp
-        "QPlatformSurface*": int, # a handle
-        "QVector< QTextLayout.FormatRange >()": [], # do we need more structure?
+        "QPixmap()": Default("PySide6.QtGui.QPixmap"),  # can't create without qApp
+        "QPlatformSurface*": int,  # a handle
+        "QVector< QTextLayout.FormatRange >()": [],  # do we need more structure?
         "uint32_t": int,
         "uint8_t": int,
         "USHRT_MAX": ushort_max,
@@ -557,8 +579,9 @@ def init_PySide6_QtGui():
 
 
 def init_PySide6_QtWidgets():
-    from PySide6.QtWidgets import QWidget, QMessageBox, QStyleOption, QStyleHintReturn, QStyleOptionComplex
-    from PySide6.QtWidgets import QGraphicsItem, QStyleOptionGraphicsItem # 5.9
+    from PySide6.QtWidgets import (QWidget, QMessageBox, QStyleOption,
+                                   QStyleHintReturn, QStyleOptionComplex,
+                                   QGraphicsItem, QStyleOptionGraphicsItem)
     type_map.update({
         "QMessageBox.StandardButtons(Yes | No)": Instance(
             "QMessageBox.StandardButtons(QMessageBox.Yes | QMessageBox.No)"),
@@ -579,7 +602,7 @@ def init_PySide6_QtSql():
     from PySide6.QtSql import QSqlDatabase
     type_map.update({
         "QLatin1StringView(QSqlDatabase.defaultConnection)": QSqlDatabase.defaultConnection,
-        "QVariant.Invalid": Invalid("Variant"), # not sure what I should create, here...
+        "QVariant.Invalid": Invalid("Variant"),  # not sure what I should create, here...
     })
     return locals()
 
@@ -603,7 +626,7 @@ def init_PySide6_QtOpenGL():
     type_map.update({
         "GLbitfield": int,
         "GLenum": int,
-        "GLfloat": float, # 5.6, MSVC 15
+        "GLfloat": float,  # 5.6, MSVC 15
         "GLint": int,
         "GLuint": int,
     })
@@ -660,6 +683,22 @@ def init_PySide6_QtBluetooth():
     return locals()
 
 
+def init_PySide6_QtGraphs():
+    from PySide6.QtGraphs import (QBarDataItem, QSurfaceDataItem)
+    QBarDataRow = typing.List[QBarDataItem]
+    QBarDataArray = typing.List[QBarDataRow]
+    QSurfaceDataRow = typing.List[QSurfaceDataItem]
+    QSurfaceDataArray = typing.List[QSurfaceDataRow]
+    type_map.update({
+        "100.0f": 100.0,
+        "QBarDataArray": QBarDataArray,
+        "QBarDataArray*": QBarDataArray,
+        "QSurfaceDataArray": QSurfaceDataArray,
+        "QSurfaceDataArray*": QSurfaceDataArray,
+    })
+    return locals()
+
+
 def init_PySide6_QtHttpServer():
     type_map.update({
         "qMakePair(1u, 1u)": (1, 1),
diff --git a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/parser.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/parser.py
index 5d86b93a5..9b48ab442 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/parser.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/parser.py
@@ -3,20 +3,17 @@
 
 import ast
 import enum
-import functools
 import keyword
 import os
 import re
 import sys
-import types
 import typing
 import warnings
 
 from types import SimpleNamespace
 from shibokensupport.signature.mapping import (type_map, update_mapping,
-    namespace, _NotCalled, ResultVariable, ArrayLikeVariable)
+    namespace, _NotCalled, ResultVariable, ArrayLikeVariable)  # noqa E:128
 from shibokensupport.signature.lib.tool import build_brace_pattern
-from shibokensupport import feature
 
 _DEBUG = False
 LIST_KEYWORDS = False
@@ -41,8 +38,9 @@ guesses, we provide an entry in 'type_map' that resolves it.
 In effect, 'type_map' maps text to real Python objects.
 """
 
+
 def _get_flag_enum_option():
-    from shiboken6 import (__version_info__ as ver,
+    from shiboken6 import (__version_info__ as ver,  # noqa F:401
                            __minimum_python_version__ as pyminver,
                            __maximum_python_version__ as pymaxver)
 
@@ -50,7 +48,7 @@ def _get_flag_enum_option():
     #              This decides between delivered vs. dev versions.
     #              When 6.4 is out, the switching mode will be gone.
     flag = ver[:2] >= (6, 4)
-    envname = "PYSIDE63_OPTION_PYTHON_ENUM"
+    envname = "PYSIDE6_OPTION_PYTHON_ENUM"
     sysname = envname.lower()
     opt = os.environ.get(envname)
     if opt:
@@ -64,27 +62,30 @@ def _get_flag_enum_option():
             try:
                 flag = ast.literal_eval(opt)
             except Exception:
-                flag = True
+                flag = False    # turn a forbidden option into an error
     elif hasattr(sys, sysname):
-        flag = getattr(sys, sysname)
+        opt2 = flag = getattr(sys, sysname)
         if not isinstance(flag, int):
-            flag = True
+            flag = False        # turn a forbidden option into an error
     p = f"\n    *** Python is at version {'.'.join(map(str, pyminver or (0,)))} now."
-    # PYSIDE-1797: Emit a warning when we may remove pep384_issue33738.cpp
-    if pyminver and pyminver >= (3, 8):
-        warnings.warn(f"{p} The file pep384_issue33738.cpp should be removed ASAP! ***")
+    q = f"\n    *** PySide is at version {'.'.join(map(str, ver[:2]))} now."
     # _PepUnicode_AsString: Fix a broken promise
     if pyminver and pyminver >= (3, 10):
         warnings.warn(f"{p} _PepUnicode_AsString can now be replaced by PyUnicode_AsUTF8! ***")
-    # PYSIDE-1960: Emit a warning when we may remove pep384_issue33738.cpp
+    # PYSIDE-1960: Emit a warning when we may remove bufferprocs_py37.(cpp|h)
     if pyminver and pyminver >= (3, 11):
         warnings.warn(f"{p} The files bufferprocs_py37.(cpp|h) should be removed ASAP! ***")
     # PYSIDE-1735: Emit a warning when we should maybe evict forgiveness mode
     if ver[:2] >= (7, 0):
-        warnings.warn(f"{p} Please drop Enum forgiveness mode in `mangled_type_getattro` ***")
+        warnings.warn(f"{q} Please drop Enum forgiveness mode in `mangled_type_getattro` ***")
+    # PYSIDE-2404: Emit a warning when we should drop uppercase offset constants
+    if ver[:2] >= (7, 0):
+        warnings.warn(f"{q} Please drop uppercase type offsets in `copyOffsetEnumStream` ***")
     # normalize the sys attribute
     setattr(sys, sysname, flag)
     os.environ[envname] = str(flag)
+    if int(flag) == 0:
+        raise RuntimeError(f"Old Enums are no longer supported. int({opt or opt2}) evaluates to 0)")
     return flag
 
 
@@ -106,6 +107,7 @@ def dprint(*args, **kw):
 
 _cache = {}
 
+
 def _parse_arglist(argstr):
     # The following is a split re. The string is broken into pieces which are
     # between the recognized strings. Because the re has groups, both the
@@ -187,7 +189,7 @@ def _handle_instance_fixup(thing):
     if not match:
         return thing
     start, stop = match.start(), match.end() - 1
-    pre, func, args = thing[:start], thing[start : stop], thing[stop:]
+    pre, func, args = thing[:start], thing[start:stop], thing[stop:]
     if func[0].isupper() or func.startswith("gl") and func[2:3].isupper():
         return thing
     # Now convert this string to snake case.
@@ -196,7 +198,7 @@ def _handle_instance_fixup(thing):
         if char.isupper():
             if idx and func[idx - 1].isupper():
                 # two upper chars are forbidden
-                return things
+                return thing
             snake_func += f"_{char.lower()}"
         else:
             snake_func += char
@@ -239,12 +241,14 @@ def try_to_guess(thing, valtype):
                 return ret
     return None
 
+
 def get_name(thing):
     if isinstance(thing, type):
         return getattr(thing, "__qualname__", thing.__name__)
     else:
         return thing.__name__
 
+
 def _resolve_value(thing, valtype, line):
     if thing in ("0", "None") and valtype:
         if valtype.startswith("PySide6.") or valtype.startswith("typing."):
@@ -297,7 +301,7 @@ def to_string(thing):
         dot = "." in str(thing) or m not in (thing.__qualname__, "builtins")
         name = get_name(thing)
         ret = m + "." + name if dot else name
-        assert(eval(ret, globals(), namespace))
+        assert (eval(ret, globals(), namespace))
         return ret
     # Note: This captures things from the typing module:
     return str(thing)
@@ -305,8 +309,9 @@ def to_string(thing):
 
 matrix_pattern = "PySide6.QtGui.QGenericMatrix"
 
+
 def handle_matrix(arg):
-    n, m, typstr = tuple(map(lambda x:x.strip(), arg.split(",")))
+    n, m, typstr = tuple(map(lambda x: x.strip(), arg.split(",")))
     assert typstr == "float"
     result = f"PySide6.QtGui.QMatrix{n}x{m}"
     return eval(result, globals(), namespace)
@@ -334,13 +339,13 @@ def _resolve_type(thing, line, level, var_handler, func_name=None):
         # Special case: Handle the generic matrices.
         if contr == matrix_pattern:
             return handle_matrix(thing)
-        contr = var_handler(_resolve_type(contr, line, level+1, var_handler))
+        contr = var_handler(_resolve_type(contr, line, level + 1, var_handler))
         if isinstance(contr, _NotCalled):
             raise SystemError("Container types must exist:", repr(contr))
         contr = to_string(contr)
         pieces = []
         for part in _parse_arglist(thing):
-            part = var_handler(_resolve_type(part, line, level+1, var_handler))
+            part = var_handler(_resolve_type(part, line, level + 1, var_handler))
             if isinstance(part, _NotCalled):
                 # fix the tag (i.e. "Missing") by repr
                 part = repr(part)
@@ -350,7 +355,7 @@ def _resolve_type(thing, line, level, var_handler, func_name=None):
         # PYSIDE-1538: Make sure that the eval does not crash.
         try:
             return eval(result, globals(), namespace)
-        except Exception as e:
+        except Exception:
             warnings.warn(f"""pyside_type_init:_resolve_type
 
                 UNRECOGNIZED:   {result!r}
@@ -429,9 +434,9 @@ def calculate_props(line):
     props.defaults = defaults
     props.kwdefaults = {}
     props.annotations = annotations
-    props.varnames = varnames = tuple(tup[0] for tup in arglist)
+    props.varnames = tuple(tup[0] for tup in arglist)
     funcname = parsed.funcname
-    shortname = funcname[funcname.rindex(".")+1:]
+    shortname = funcname[funcname.rindex(".") + 1:]
     props.name = shortname
     props.multi = parsed.multi
     fix_variables(props, line)
@@ -477,7 +482,6 @@ def fix_variables(props, line):
         else:
             diff -= 1
     if retvars:
-        rvs = []
         retvars = list(handle_retvar(rv) if isinstance(rv, ArrayLikeVariable) else rv
                        for rv in retvars)
         if len(retvars) == 1:
diff --git a/sources/shiboken6/shibokenmodule/shibokenmodule.cpp b/sources/shiboken6/shibokenmodule/shibokenmodule.cpp
new file mode 100644
index 000000000..5c6219885
--- /dev/null
+++ b/sources/shiboken6/shibokenmodule/shibokenmodule.cpp
@@ -0,0 +1,119 @@
+// 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
+
+// @snippet isvalid
+bool isValid = Shiboken::Object::isValid(%1, false);
+%PYARG_0 = %CONVERTTOPYTHON[bool](isValid);
+// @snippet isvalid
+
+// @snippet wrapinstance
+auto *pyType = reinterpret_cast<PyTypeObject *>(%2);
+if (Shiboken::ObjectType::checkType(pyType)) {
+    auto *ptr = reinterpret_cast<void *>(%1);
+    if (auto *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(ptr)) {
+        Py_INCREF(wrapper);
+        %PYARG_0 = reinterpret_cast<PyObject *>(wrapper);
+    } else {
+        %PYARG_0 = Shiboken::Object::newObject(pyType, ptr, false, true);
+    }
+} else {
+    PyErr_SetString(PyExc_TypeError, "You need a shiboken-based type.");
+}
+// @snippet wrapinstance
+
+// @snippet getcpppointer
+if (Shiboken::Object::checkType(%1)) {
+    std::vector<void*> ptrs = Shiboken::Object::cppPointers(reinterpret_cast<SbkObject *>(%1));
+    %PYARG_0 = PyTuple_New(ptrs.size());
+    for (std::size_t i = 0; i < ptrs.size(); ++i)
+        PyTuple_SET_ITEM(%PYARG_0, i, PyLong_FromVoidPtr(ptrs[i]));
+} else {
+    PyErr_SetString(PyExc_TypeError, "You need a shiboken-based type.");
+}
+// @snippet getcpppointer
+
+// @snippet delete
+if (Shiboken::Object::checkType(%1)) {
+    Shiboken::Object::callCppDestructors(reinterpret_cast<SbkObject *>(%1));
+} else {
+    PyErr_SetString(PyExc_TypeError, "You need a shiboken-based type.");
+}
+// @snippet delete
+
+// @snippet ownedbypython
+if (Shiboken::Object::checkType(%1)) {
+    bool hasOwnership = Shiboken::Object::hasOwnership(reinterpret_cast<SbkObject *>(%1));
+    %PYARG_0 = %CONVERTTOPYTHON[bool](hasOwnership);
+} else {
+    PyErr_SetString(PyExc_TypeError, "You need a shiboken-based type.");
+}
+// @snippet ownedbypython
+
+// @snippet createdbypython
+if (Shiboken::Object::checkType(%1)) {
+    bool wasCreatedByPython = Shiboken::Object::wasCreatedByPython(reinterpret_cast<SbkObject *>(%1));
+    %PYARG_0 = %CONVERTTOPYTHON[bool](wasCreatedByPython);
+} else {
+    PyErr_SetString(PyExc_TypeError, "You need a shiboken-based type.");
+}
+// @snippet createdbypython
+
+// @snippet disassembleframe
+Shiboken::AutoDecRef label(PyObject_Str(%1));
+const char *marker = Shiboken::String::toCString(label);
+disassembleFrame(marker);
+Py_INCREF(Py_None);
+%PYARG_0 = Py_None;
+// @snippet disassembleframe
+
+// @snippet dump
+if (!Shiboken::Object::checkType(%1)) {
+    %PYARG_0 = Shiboken::String::fromCString("Ordinary Python type.");
+} else {
+    std::string str = Shiboken::Object::info(reinterpret_cast<SbkObject *>(%1));
+    %PYARG_0 = Shiboken::String::fromCString(str.c_str());
+}
+// @snippet dump
+
+// @snippet getallvalidwrappers
+const auto setAll = Shiboken::BindingManager::instance().getAllPyObjects();
+PyObject* listAll = PyList_New(0);
+if (listAll == nullptr)
+    return nullptr;
+for (auto *o : setAll) {
+    if (o != nullptr) {
+        if (PyList_Append(listAll, o) != 0) {
+            Py_DECREF(listAll);
+            return nullptr;
+        }
+    }
+}
+return listAll;
+// @snippet getallvalidwrappers
+
+// @snippet dumptypegraph
+const bool ok = Shiboken::BindingManager::instance().dumpTypeGraph(%1);
+%PYARG_0 = %CONVERTTOPYTHON[bool](ok);
+// @snippet dumptypegraph
+
+// @snippet dumpwrappermap
+Shiboken::BindingManager::instance().dumpWrapperMap();
+// @snippet dumpwrappermap
+
+// @snippet dumpconverters
+Shiboken::Conversions::dumpConverters();
+// @snippet dumpconverters
+
+// @snippet init
+// Add __version__ and __version_info__ attributes to the module
+PyObject* version = PyTuple_New(5);
+PyTuple_SET_ITEM(version, 0, PyLong_FromLong(SHIBOKEN_MAJOR_VERSION));
+PyTuple_SET_ITEM(version, 1, PyLong_FromLong(SHIBOKEN_MINOR_VERSION));
+PyTuple_SET_ITEM(version, 2, PyLong_FromLong(SHIBOKEN_MICRO_VERSION));
+PyTuple_SET_ITEM(version, 3, Shiboken::String::fromCString(SHIBOKEN_RELEASE_LEVEL));
+PyTuple_SET_ITEM(version, 4, PyLong_FromLong(SHIBOKEN_SERIAL));
+PyModule_AddObject(module, "__version_info__", version);
+PyModule_AddStringConstant(module, "__version__", SHIBOKEN_VERSION);
+VoidPtr::addVoidPtrToModule(module);
+Shiboken::initShibokenSupport(module);
+// @snippet init
diff --git a/sources/shiboken6/shibokenmodule/typesystem_shiboken.xml b/sources/shiboken6/shibokenmodule/typesystem_shiboken.xml
index 81919d6c3..acb522ecc 100644
--- a/sources/shiboken6/shibokenmodule/typesystem_shiboken.xml
+++ b/sources/shiboken6/shibokenmodule/typesystem_shiboken.xml
@@ -1,13 +1,14 @@
 <?xml version="1.0" ?>
+<!--
+// 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
+-->
 <typesystem package="Shiboken">
     <primitive-type name="bool" />
     <primitive-type name="unsigned long" />
     <primitive-type name="size_t" />
     <add-function signature="isValid(PyObject*)" return-type="bool">
-        <inject-code>
-            bool isValid = Shiboken::Object::isValid(%1, false);
-            %PYARG_0 = %CONVERTTOPYTHON[bool](isValid);
-        </inject-code>
+        <inject-code file="shibokenmodule.cpp" snippet="isvalid"/>
     </add-function>
 
     <add-function signature="invalidate(PyObject*)">
@@ -17,125 +18,53 @@
     </add-function>
 
     <add-function signature="wrapInstance(size_t, PyTypeObject)" return-type="PyObject*">
-        <inject-code>
-            auto *pyType = reinterpret_cast&lt;PyTypeObject *&gt;(%2);
-            if (Shiboken::ObjectType::checkType(pyType)) {
-                %PYARG_0 = Shiboken::Object::newObject(pyType,
-                                                       reinterpret_cast&lt;void *&gt;(%1),
-                                                       false, true);
-            } else {
-                PyErr_SetString(PyExc_TypeError, "You need a shiboken-based type.");
-            }
-        </inject-code>
+        <inject-code file="shibokenmodule.cpp" snippet="wrapinstance"/>
     </add-function>
 
    <add-function signature="getCppPointer(PyObject*)" return-type="PySequence*">
-        <inject-code>
-            if (Shiboken::Object::checkType(%1)) {
-                std::vector&lt;void*> ptrs = Shiboken::Object::cppPointers(reinterpret_cast&lt;SbkObject *&gt;(%1));
-                %PYARG_0 = PyTuple_New(ptrs.size());
-                for (std::size_t i = 0; i &lt; ptrs.size(); ++i)
-                    PyTuple_SET_ITEM(%PYARG_0, i, PyLong_FromVoidPtr(ptrs[i]));
-            } else {
-                PyErr_SetString(PyExc_TypeError, "You need a shiboken-based type.");
-            }
-        </inject-code>
+        <inject-code file="shibokenmodule.cpp" snippet="getcpppointer"/>
    </add-function>
 
    <add-function signature="delete(PyObject*)">
-        <inject-code>
-            if (Shiboken::Object::checkType(%1)) {
-                Shiboken::Object::callCppDestructors(reinterpret_cast&lt;SbkObject *&gt;(%1));
-            } else {
-                PyErr_SetString(PyExc_TypeError, "You need a shiboken-based type.");
-            }
-        </inject-code>
+        <inject-code file="shibokenmodule.cpp" snippet="delete"/>
    </add-function>
 
     <add-function signature="ownedByPython(PyObject*)" return-type="bool">
-        <inject-code>
-            if (Shiboken::Object::checkType(%1)) {
-                bool hasOwnership = Shiboken::Object::hasOwnership(reinterpret_cast&lt;SbkObject *&gt;(%1));
-                %PYARG_0 = %CONVERTTOPYTHON[bool](hasOwnership);
-            } else {
-                PyErr_SetString(PyExc_TypeError, "You need a shiboken-based type.");
-            }
-        </inject-code>
+        <inject-code file="shibokenmodule.cpp" snippet="ownedbypython"/>
     </add-function>
 
     <add-function signature="createdByPython(PyObject*)" return-type="bool">
-        <inject-code>
-            if (Shiboken::Object::checkType(%1)) {
-                bool wasCreatedByPython = Shiboken::Object::wasCreatedByPython(reinterpret_cast&lt;SbkObject *&gt;(%1));
-                %PYARG_0 = %CONVERTTOPYTHON[bool](wasCreatedByPython);
-            } else {
-                PyErr_SetString(PyExc_TypeError, "You need a shiboken-based type.");
-            }
-        </inject-code>
+        <inject-code file="shibokenmodule.cpp" snippet="createdbypython"/>
     </add-function>
 
     <add-function signature="disassembleFrame(PyObject*)" return-type="PyObject">
-        <inject-code>
-            Shiboken::AutoDecRef label(PyObject_Str(%1));
-            const char *marker = Shiboken::String::toCString(label);
-            disassembleFrame(marker);
-            Py_INCREF(Py_None);
-            %PYARG_0 = Py_None;
-        </inject-code>
+        <inject-code file="shibokenmodule.cpp" snippet="disassembleframe"/>
     </add-function>
 
     <add-function signature="dump(PyObject*)" return-type="const char *">
-        <inject-code>
-            if (!Shiboken::Object::checkType(%1)) {
-                %PYARG_0 = Shiboken::String::fromCString("Ordinary Python type.");
-            } else {
-                std::string str = Shiboken::Object::info(reinterpret_cast&lt;SbkObject *&gt;(%1));
-                %PYARG_0 = Shiboken::String::fromCString(str.c_str());
-            }
-        </inject-code>
+        <inject-code file="shibokenmodule.cpp" snippet="dump"/>
     </add-function>
 
     <add-function signature="getAllValidWrappers(void)" return-type="PySequence*">
-        <inject-code>
-            const auto setAll = Shiboken::BindingManager::instance().getAllPyObjects();
-            PyObject* listAll = PyList_New(0);
-            if (listAll == nullptr)
-                return nullptr;
+        <inject-code file="shibokenmodule.cpp" snippet="getallvalidwrappers"/>
+    </add-function>
 
-            for (auto *o : setAll) {
-                if (o != nullptr) {
-                    if (PyList_Append(listAll, o) != 0) {
-                        Py_DECREF(listAll);
-                        return nullptr;
-                    }
-                }
-            }
-            return listAll;
-        </inject-code>
+    <add-function signature="dumpTypeGraph(const char *@fileName@)" return-type="bool">
+        <inject-code file="shibokenmodule.cpp" snippet="dumptypegraph"/>
     </add-function>
 
-    <add-function signature="_unpickle_enum(PyObject*, PyObject*)" return-type="PyObject*">
-        <inject-code>
-            %PYARG_0 = Shiboken::Enum::unpickleEnum(%1, %2);
-        </inject-code>
+    <add-function signature="dumpWrapperMap()">
+        <inject-code file="shibokenmodule.cpp" snippet="dumpwrappermap"/>
+    </add-function>
+
+    <add-function signature="dumpConverters()">
+        <inject-code file="shibokenmodule.cpp" snippet="dumpconverters"/>
     </add-function>
 
     <extra-includes>
         <include file-name="sbkversion.h" location="local"/>
         <include file-name="voidptr.h" location="local"/>
+        <include file-name="sbkconverter_p.h" location="local"/>
     </extra-includes>
-    <inject-code position="end">
-        // Add __version__ and __version_info__ attributes to the module
-        PyObject* version = PyTuple_New(5);
-        PyTuple_SET_ITEM(version, 0, PyLong_FromLong(SHIBOKEN_MAJOR_VERSION));
-        PyTuple_SET_ITEM(version, 1, PyLong_FromLong(SHIBOKEN_MINOR_VERSION));
-        PyTuple_SET_ITEM(version, 2, PyLong_FromLong(SHIBOKEN_MICRO_VERSION));
-        PyTuple_SET_ITEM(version, 3, Shiboken::String::fromCString(SHIBOKEN_RELEASE_LEVEL));
-        PyTuple_SET_ITEM(version, 4, PyLong_FromLong(SHIBOKEN_SERIAL));
-        PyModule_AddObject(module, "__version_info__", version);
-        PyModule_AddStringConstant(module, "__version__", SHIBOKEN_VERSION);
-        VoidPtr::addVoidPtrToModule(module);
-
-        Shiboken::initShibokenSupport(module);
-    </inject-code>
+     <inject-code position="end" file="shibokenmodule.cpp" snippet="init"/>
 </typesystem>
diff --git a/sources/shiboken6/tests/CMakeLists.txt b/sources/shiboken6/tests/CMakeLists.txt
index c1fca5134..05f6e9e60 100644
--- a/sources/shiboken6/tests/CMakeLists.txt
+++ b/sources/shiboken6/tests/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)
 
 if(BUILD_TESTS)
@@ -11,6 +14,8 @@ if(NOT DEFINED MINIMAL_TESTS)
     add_subdirectory(libother)
 endif()
 
+shiboken_get_debug_level(debug_level)
+
 if(WIN32 OR DEFINED AVOID_PROTECTED_HACK)
     message(STATUS "Tests will be generated avoiding the protected hack!")
     set(GENERATOR_EXTRA_FLAGS --avoid-protected-hack)
@@ -18,6 +23,7 @@ else()
     message(STATUS "Tests will be generated using the protected hack!")
     set(GENERATOR_EXTRA_FLAGS )
 endif()
+list(APPEND GENERATOR_EXTRA_FLAGS ${SHIBOKEN_GENERATOR_EXTRA_FLAGS} ${debug_level})
 
 add_subdirectory(minimalbinding)
 if(NOT DEFINED MINIMAL_TESTS)
@@ -40,13 +46,18 @@ list(SORT TEST_FILES)
 set(test_blacklist "")
 
 if(SHIBOKEN_IS_CROSS_BUILD)
-    # PYTHON_EXECUTABLE will be empty when cross-building.
+    # Python_EXECUTABLE will be empty when cross-building.
     message(WARNING
         "Running tests when cross-compiling is not supported because it would require running "
         "a target python interpreter which might have a different architecture than the host."
     )
 else()
-    find_package(PythonInterp REQUIRED)
+    find_package(
+        Python
+        ${USE_PYTHON_VERSION}
+        REQUIRED
+        COMPONENTS Interpreter Development
+    )
 endif()
 
 if(NOT CTEST_TESTING_TIMEOUT)
@@ -60,7 +71,7 @@ foreach(test_file ${TEST_FILES})
     string(REGEX MATCH "/([^/]+)(binding|module)/([^/]+)_test.py" tmp ${test_file})
     set(test_name "${CMAKE_MATCH_1}_${CMAKE_MATCH_3}")
     list(FIND test_blacklist ${test_name} expect_fail)
-    add_test(${test_name} ${PYTHON_EXECUTABLE} ${test_file})
+    add_test(${test_name} ${Python_EXECUTABLE} ${test_file})
     set_tests_properties(${test_name} PROPERTIES ENVIRONMENT "BUILD_DIR=${BUILD_DIR}")
     set_tests_properties(${test_name} PROPERTIES TIMEOUT ${CTEST_TESTING_TIMEOUT})
     if (${expect_fail} GREATER -1)
diff --git a/sources/shiboken6/tests/dumpcodemodel/CMakeLists.txt b/sources/shiboken6/tests/dumpcodemodel/CMakeLists.txt
index 44652e7e5..e7dbef961 100644
--- a/sources/shiboken6/tests/dumpcodemodel/CMakeLists.txt
+++ b/sources/shiboken6/tests/dumpcodemodel/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 add_executable(dumpcodemodel main.cpp)
 
 target_include_directories(dumpcodemodel
@@ -9,5 +12,5 @@ target_include_directories(dumpcodemodel
 target_link_libraries(dumpcodemodel
     PRIVATE
         apiextractor
-        Qt${QT_MAJOR_VERSION}::Core
+        Qt::Core
 )
diff --git a/sources/shiboken6/tests/dumpcodemodel/main.cpp b/sources/shiboken6/tests/dumpcodemodel/main.cpp
index 1befca260..eb876634c 100644
--- a/sources/shiboken6/tests/dumpcodemodel/main.cpp
+++ b/sources/shiboken6/tests/dumpcodemodel/main.cpp
@@ -38,7 +38,7 @@ static void formatDebugOutput(const FileModelItem &dom, bool verbose)
         QDebug debug(&output);
         if (verbose)
             debug.setVerbosity(3);
-        debug << dom.data();
+        debug << dom.get();
     }
     std::cout << qPrintable(output) << '\n';
 }
@@ -48,14 +48,14 @@ static const char *primitiveTypes[] = {
     "float", "double"
 };
 
-static inline QString nameAttribute() { return QStringLiteral("name"); }
+constexpr auto nameAttribute = "name"_L1;
 
 static void formatXmlClass(QXmlStreamWriter &writer, const ClassModelItem &klass);
 
 static void formatXmlEnum(QXmlStreamWriter &writer, const EnumModelItem &en)
 {
     writer.writeStartElement(u"enum-type"_s);
-    writer.writeAttribute(nameAttribute(), en->name());
+    writer.writeAttribute(nameAttribute, en->name());
     writer.writeEndElement();
 }
 
@@ -97,7 +97,7 @@ static void formatXmlClass(QXmlStreamWriter &writer, const ClassModelItem &klass
     formatXmlLocationComment(writer, klass);
     writer.writeStartElement(isValueType ? u"value-type"_s
                                          : u"object-type"_s);
-    writer.writeAttribute(nameAttribute(), klass->name());
+    writer.writeAttribute(nameAttribute, klass->name());
     formatXmlScopeMembers(writer, klass);
     writer.writeEndElement();
 }
@@ -118,7 +118,7 @@ static void startXmlNamespace(QXmlStreamWriter &writer, const NamespaceModelItem
 {
     formatXmlLocationComment(writer, nsp);
     writer.writeStartElement(u"namespace-type"_s);
-    writer.writeAttribute(nameAttribute(), nsp->name());
+    writer.writeAttribute(nameAttribute, nsp->name());
 }
 
 static void formatXmlNamespaceMembers(QXmlStreamWriter &writer, const NamespaceModelItem &nsp)
@@ -170,7 +170,7 @@ static void formatXmlOutput(const FileModelItem &dom)
                         QDateTime::currentDateTime().toString(Qt::ISODate));
     for (auto p : primitiveTypes) {
         writer.writeStartElement(u"primitive-type"_s);
-        writer.writeAttribute(nameAttribute(), QLatin1StringView(p));
+        writer.writeAttribute(nameAttribute, QLatin1StringView(p));
         writer.writeEndElement();
     }
     formatXmlNamespaceMembers(writer, dom);
@@ -245,7 +245,7 @@ int main(int argc, char **argv)
     optJoinNamespaces = parser.isSet(joinNamespacesOption);
 
     const FileModelItem dom = AbstractMetaBuilderPrivate::buildDom(arguments, true, level, 0);
-    if (dom.isNull()) {
+    if (!dom) {
         QString message = u"Unable to parse "_s + positionalArguments.join(u' ');
         std::cerr << qPrintable(message) << '\n';
         return -2;
diff --git a/sources/shiboken6/tests/libminimal/CMakeLists.txt b/sources/shiboken6/tests/libminimal/CMakeLists.txt
index f906bdb84..4a10f96bf 100644
--- a/sources/shiboken6/tests/libminimal/CMakeLists.txt
+++ b/sources/shiboken6/tests/libminimal/CMakeLists.txt
@@ -1,9 +1,17 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(libminimal)
 
 set(libminimal_SRC
-obj.cpp
-listuser.cpp
-typedef.cpp
+containeruser.cpp containeruser.h
+libminimalmacros.h
+listuser.cpp listuser.h
+minbool.h
+obj.cpp obj.h
+spanuser.cpp spanuser.h
+typedef.cpp typedef.h
+val.h
 )
 
 add_library(libminimal SHARED ${libminimal_SRC})
diff --git a/sources/shiboken6/tests/libminimal/containeruser.cpp b/sources/shiboken6/tests/libminimal/containeruser.cpp
new file mode 100644
index 000000000..29af52aef
--- /dev/null
+++ b/sources/shiboken6/tests/libminimal/containeruser.cpp
@@ -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
+
+#include "containeruser.h"
+
+#include <algorithm>
+#include <numeric>
+
+ContainerUser::ContainerUser() : m_intVector{1, 2, 3}, m_intArray{1, 2, 3}
+{
+}
+
+ContainerUser::~ContainerUser() = default;
+
+std::vector<int> ContainerUser::createIntVector(int num)
+{
+    std::vector<int> retval(num);
+    std::iota(retval.begin(), retval.end(), 0);
+    return retval;
+}
+
+int ContainerUser::sumIntVector(const std::vector<int> &intVector)
+{
+    return std::accumulate(intVector.cbegin(), intVector.cend(), 0);
+}
+
+std::vector<int> &ContainerUser::intVector()
+{
+    return m_intVector;
+}
+
+void ContainerUser::setIntVector(const std::vector<int> &v)
+{
+    m_intVector = v;
+}
+
+std::array<int, 3> ContainerUser::createIntArray()
+{
+    return {1, 2, 3};
+}
+
+int ContainerUser::sumIntArray(const std::array<int, 3> &intArray)
+{
+    return std::accumulate(intArray.cbegin(), intArray.cend(), 0);
+}
+
+std::array<int, 3> &ContainerUser::intArray()
+{
+    return m_intArray;
+}
+
+void ContainerUser::setIntArray(const std::array<int, 3> &a)
+{
+    m_intArray = a;
+}
diff --git a/sources/shiboken6/tests/libminimal/containeruser.h b/sources/shiboken6/tests/libminimal/containeruser.h
new file mode 100644
index 000000000..55e4020ec
--- /dev/null
+++ b/sources/shiboken6/tests/libminimal/containeruser.h
@@ -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
+
+#ifndef CONTAINERUSER_H
+#define CONTAINERUSER_H
+
+#include "libminimalmacros.h"
+
+#include <array>
+#include <vector>
+
+/// Exercise simple, sequential containers. More advanced tests are in ListUser
+class LIBMINIMAL_API ContainerUser
+{
+public:
+    ContainerUser();
+    ~ContainerUser();
+
+    static std::vector<int> createIntVector(int num);
+    static int sumIntVector(const std::vector<int> &intVector);
+
+    std::vector<int> &intVector();
+    void setIntVector(const  std::vector<int> &);
+
+    static std::array<int, 3> createIntArray();
+    static int sumIntArray(const std::array<int, 3> &intArray);
+
+    std::array<int, 3> &intArray();
+    void setIntArray(const  std::array<int, 3> &);
+
+private:
+    std::vector<int> m_intVector;
+    std::array<int, 3> m_intArray;
+};
+
+#endif // CONTAINERUSER_H
diff --git a/sources/shiboken6/tests/libminimal/libminimalmacros.h b/sources/shiboken6/tests/libminimal/libminimalmacros.h
index e0dfdd196..099c1f1de 100644
--- a/sources/shiboken6/tests/libminimal/libminimalmacros.h
+++ b/sources/shiboken6/tests/libminimal/libminimalmacros.h
@@ -22,4 +22,28 @@
 #  define LIBMINIMAL_API LIBMINIMAL_IMPORT
 #endif
 
+#define LIBMINIMAL_DEFAULT_COPY(Class) \
+    Class(const Class &) noexcept = default; \
+    Class &operator=(const Class &) noexcept = default;
+
+#define LIBMINIMAL_DISABLE_COPY(Class) \
+    Class(const Class &) = delete;\
+    Class &operator=(const Class &) = delete;
+
+#define LIBMINIMAL_DEFAULT_MOVE(Class) \
+    Class(Class &&) noexcept = default; \
+    Class &operator=(Class &&) noexcept = default;
+
+#define LIBMINIMAL_DEFAULT_COPY_MOVE(Class) \
+    LIBMINIMAL_DEFAULT_COPY(Class) \
+    LIBMINIMAL_DEFAULT_MOVE(Class)
+
+#define LIBMINIMAL_DISABLE_MOVE(Class) \
+    Class(Class &&) = delete; \
+    Class &operator=(Class &&) = delete;
+
+#define LIBMINIMAL_DISABLE_COPY_MOVE(Class) \
+    LIBMINIMAL_DISABLE_COPY(Class) \
+    LIBMINIMAL_DISABLE_MOVE(Class)
+
 #endif // LIBMINIMALMACROS_H
diff --git a/sources/shiboken6/tests/libminimal/listuser.cpp b/sources/shiboken6/tests/libminimal/listuser.cpp
index 14ac1c7ee..93c399542 100644
--- a/sources/shiboken6/tests/libminimal/listuser.cpp
+++ b/sources/shiboken6/tests/libminimal/listuser.cpp
@@ -1,29 +1,35 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <numeric>
-#include <cstdlib>
 #include "listuser.h"
 
 #include <algorithm>
+#include <cstdlib>
 #include <numeric>
 
-std::list<int>
-ListUser::createIntList(int num)
+std::list<int> ListUser::createIntList(int num)
 {
     std::list<int> retval(num);
     std::iota(retval.begin(), retval.end(), 0);
     return retval;
 }
 
-int
-ListUser::sumIntList(std::list<int> intList)
+int ListUser::sumIntList(std::list<int> intList)
 {
     return std::accumulate(intList.begin(), intList.end(), 0);
 }
 
-std::list<MinBool>
-ListUser::createMinBoolList(MinBool mb1, MinBool mb2)
+int ListUser::sumIntListDefaultParamConstRef(const std::list<int> &intList)
+{
+    return sumIntList(intList);
+}
+
+int ListUser::sumIntListDefaultParam(std::list<int> intList)
+{
+    return sumIntList(intList);
+}
+
+std::list<MinBool> ListUser::createMinBoolList(MinBool mb1, MinBool mb2)
 {
     std::list<MinBool> retval;
     retval.push_back(mb1);
@@ -31,8 +37,7 @@ ListUser::createMinBoolList(MinBool mb1, MinBool mb2)
     return retval;
 }
 
-MinBool
-ListUser::oredMinBoolList(std::list<MinBool> minBoolList)
+MinBool ListUser::oredMinBoolList(std::list<MinBool> minBoolList)
 {
     MinBool result(false);
     for (const auto &m : minBoolList)
@@ -40,8 +45,7 @@ ListUser::oredMinBoolList(std::list<MinBool> minBoolList)
     return result;
 }
 
-std::list<Val>
-ListUser::createValList(int num)
+std::list<Val> ListUser::createValList(int num)
 {
     std::list<Val> retval;
     for (int i = 0; i < num; ++i)
@@ -49,17 +53,14 @@ ListUser::createValList(int num)
     return retval;
 }
 
-int
-ListUser::sumValList(std::list<Val> valList)
+int ListUser::sumValList(std::list<Val> valList)
 {
     int total = 0;
     for (const auto &v : valList)
         total += v.valId();
     return total;
 }
-
-std::list<Obj*>
-ListUser::createObjList(Obj* o1, Obj* o2)
+std::list<Obj*> ListUser::createObjList(Obj* o1, Obj* o2)
 {
     std::list<Obj*> retval;
     retval.push_back(o1);
@@ -67,8 +68,7 @@ ListUser::createObjList(Obj* o1, Obj* o2)
     return retval;
 }
 
-int
-ListUser::sumObjList(std::list<Obj*> objList)
+int ListUser::sumObjList(std::list<Obj*> objList)
 {
     int total = 0;
     for (const auto *obj : objList)
@@ -76,8 +76,7 @@ ListUser::sumObjList(std::list<Obj*> objList)
     return total;
 }
 
-std::list<std::list<int> >
-ListUser::createListOfIntLists(int num)
+std::list<std::list<int> > ListUser::createListOfIntLists(int num)
 {
     std::list<std::list<int> > retval;
     for (int i = 0; i < num; ++i)
@@ -85,8 +84,7 @@ ListUser::createListOfIntLists(int num)
     return retval;
 }
 
-int
-ListUser::sumListOfIntLists(std::list<std::list<int> > intListList)
+int ListUser::sumListOfIntLists(std::list<std::list<int> > intListList)
 {
     int total = 0;
     for (const auto &list : intListList)
diff --git a/sources/shiboken6/tests/libminimal/listuser.h b/sources/shiboken6/tests/libminimal/listuser.h
index 2254cb138..9904ef27d 100644
--- a/sources/shiboken6/tests/libminimal/listuser.h
+++ b/sources/shiboken6/tests/libminimal/listuser.h
@@ -4,16 +4,21 @@
 #ifndef LISTUSER_H
 #define LISTUSER_H
 
-#include <list>
 #include "obj.h"
 #include "val.h"
 #include "minbool.h"
 
 #include "libminimalmacros.h"
 
+#include <list>
+
 struct LIBMINIMAL_API ListUser
 {
-    virtual ~ListUser() {}
+    LIBMINIMAL_DEFAULT_COPY(ListUser)
+    LIBMINIMAL_DISABLE_MOVE(ListUser)
+
+    ListUser() noexcept = default;
+    virtual ~ListUser() = default;
 
     // List of C++ primitive type items
     virtual std::list<int> createIntList(int num);
@@ -21,6 +26,9 @@ struct LIBMINIMAL_API ListUser
     virtual int sumIntList(std::list<int> intList);
     int callSumIntList(std::list<int> intList) { return sumIntList(intList); }
 
+    int sumIntListDefaultParamConstRef(const std::list<int> &intList = {1, 2, 3});
+    int sumIntListDefaultParam(std::list<int> intList = {1, 2, 3});
+
     // List of C++ MinBool objects used as primitives in Python
     virtual std::list<MinBool> createMinBoolList(MinBool mb1, MinBool mb2);
     std::list<MinBool> callCreateMinBoolList(MinBool mb1, MinBool mb2) { return createMinBoolList(mb1, mb2); }
diff --git a/sources/shiboken6/tests/libminimal/minbool.h b/sources/shiboken6/tests/libminimal/minbool.h
index f75e458da..e460f466b 100644
--- a/sources/shiboken6/tests/libminimal/minbool.h
+++ b/sources/shiboken6/tests/libminimal/minbool.h
@@ -13,9 +13,10 @@ public:
     bool value() const { return m_value; }
     inline MinBool operator!() const { return MinBool(!m_value); }
     inline MinBool& operator|=(const MinBool& other) {
-        m_value = m_value | other.m_value;
+        m_value |= other.m_value;
         return *this;
     }
+
 private:
     bool m_value;
 };
@@ -30,12 +31,16 @@ inline bool operator!=(MinBool b1, MinBool b2) { return (!b1).value() != (!b2).v
 class LIBMINIMAL_API MinBoolUser
 {
 public:
-    MinBoolUser() : m_minbool(MinBool(false)) {}
-    virtual ~MinBoolUser() {}
+    LIBMINIMAL_DEFAULT_COPY(MinBoolUser)
+    LIBMINIMAL_DISABLE_MOVE(MinBoolUser)
+
+    MinBoolUser() noexcept : m_minbool(MinBool(false)) {}
+    virtual ~MinBoolUser() = default;
     inline MinBool minBool() { return m_minbool; }
     inline void setMinBool(MinBool minBool) { m_minbool = minBool; }
     virtual MinBool invertedMinBool() { return !m_minbool; }
     inline MinBool callInvertedMinBool() { return invertedMinBool(); }
+
 private:
     MinBool m_minbool;
 };
diff --git a/sources/shiboken6/tests/libminimal/obj.cpp b/sources/shiboken6/tests/libminimal/obj.cpp
index 0e49fee8b..a63a9c3c9 100644
--- a/sources/shiboken6/tests/libminimal/obj.cpp
+++ b/sources/shiboken6/tests/libminimal/obj.cpp
@@ -3,14 +3,13 @@
 
 #include "obj.h"
 
-Obj::Obj(int objId) : m_objId(objId)
+Obj::Obj(int objId) noexcept : m_objId(objId)
 {
 }
 
 Obj::~Obj() = default;
 
-bool
-Obj::virtualMethod(int val)
+bool Obj::virtualMethod(int val)
 {
     return !bool(val%2);
 }
diff --git a/sources/shiboken6/tests/libminimal/obj.h b/sources/shiboken6/tests/libminimal/obj.h
index 55a798c02..be0bfb52b 100644
--- a/sources/shiboken6/tests/libminimal/obj.h
+++ b/sources/shiboken6/tests/libminimal/obj.h
@@ -9,7 +9,9 @@
 class LIBMINIMAL_API Obj
 {
 public:
-    explicit Obj(int objId);
+    LIBMINIMAL_DISABLE_COPY_MOVE(Obj)
+
+    explicit Obj(int objId) noexcept;
     virtual ~Obj();
 
     int objId() const { return m_objId; }
@@ -25,8 +27,6 @@ public:
     Obj* callPassObjectTypeReference(Obj& obj) { return passObjectTypeReference(obj); }
 
 private:
-    Obj(const Obj&);
-    Obj& operator=(const Obj&);
     int m_objId;
 };
 
diff --git a/sources/shiboken6/tests/libminimal/spanuser.cpp b/sources/shiboken6/tests/libminimal/spanuser.cpp
new file mode 100644
index 000000000..fea9cd68e
--- /dev/null
+++ b/sources/shiboken6/tests/libminimal/spanuser.cpp
@@ -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
+
+#include "spanuser.h"
+
+#include <numeric>
+
+SpanUser::SpanUser() = default;
+
+bool SpanUser::enabled()
+{
+#if __cplusplus >= 202002L
+    return true;
+#else
+    return false;
+#endif
+}
+
+#if __cplusplus >= 202002L
+IntSpan3 SpanUser::getIntSpan3()
+{
+    static int iv[] = {1, 2, 3};
+    return IntSpan3(iv);
+}
+
+IntSpan SpanUser::getIntSpan()
+{
+    static int iv[] = {1, 2, 3};
+    return IntSpan(iv);
+}
+
+ConstIntSpan3 SpanUser::getConstIntSpan3()
+{
+    static const int civ[] = {1, 2, 3};
+    return ConstIntSpan3(civ);
+}
+
+IntSpan3 SpanUser::getIntSpan3_OpaqueContainer()
+{
+    static int iv[] = {1, 2, 3};
+    return IntSpan3(iv);
+}
+
+int SpanUser::sumIntSpan3(IntSpan3 isp3)
+{
+     return std::accumulate(isp3.begin(), isp3.end(), 0);
+}
+
+int SpanUser::sumIntSpan(IntSpan isp)
+{
+     return std::accumulate(isp.begin(), isp.end(), 0);
+}
+
+int SpanUser::sumConstIntSpan3(ConstIntSpan3 ispc3)
+{
+    return std::accumulate(ispc3.begin(), ispc3.end(), 0);
+}
+#endif // C++ 20
diff --git a/sources/shiboken6/tests/libminimal/spanuser.h b/sources/shiboken6/tests/libminimal/spanuser.h
new file mode 100644
index 000000000..c78ba35e7
--- /dev/null
+++ b/sources/shiboken6/tests/libminimal/spanuser.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 SPANUSER_H
+#define SPANUSER_H
+
+#include "libminimalmacros.h"
+
+#if __cplusplus >= 202002L
+#  include <span>
+
+using IntSpan3 = std::span<int, 3>;
+using IntSpan = std::span<int>;
+using ConstIntSpan3 = std::span<const int, 3>;
+#endif
+
+struct LIBMINIMAL_API SpanUser
+{
+    SpanUser();
+
+    static bool enabled();
+
+#if __cplusplus >= 202002L
+    static IntSpan3 getIntSpan3();
+    static IntSpan getIntSpan();
+    static ConstIntSpan3 getConstIntSpan3();
+    static IntSpan3 getIntSpan3_OpaqueContainer();
+
+    static int sumIntSpan3(IntSpan3 isp3);
+    static int sumIntSpan(IntSpan isp);
+    static int sumConstIntSpan3(ConstIntSpan3 ispc3);
+#endif // C++ 20
+};
+
+#endif // SPANUSER_H
diff --git a/sources/shiboken6/tests/libminimal/val.h b/sources/shiboken6/tests/libminimal/val.h
index af53263bd..50f090a7d 100644
--- a/sources/shiboken6/tests/libminimal/val.h
+++ b/sources/shiboken6/tests/libminimal/val.h
@@ -9,8 +9,10 @@
 class LIBMINIMAL_API Val
 {
 public:
-    explicit Val(int valId) : m_valId(valId) {}
-    virtual ~Val() {}
+    explicit Val(int valId) noexcept : m_valId(valId) {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(Val)
+
+    virtual ~Val() = default;
 
     int valId() const { return m_valId; }
     void setValId(int valId) { m_valId = valId; }
diff --git a/sources/shiboken6/tests/libother/CMakeLists.txt b/sources/shiboken6/tests/libother/CMakeLists.txt
index c078d3546..0379d740b 100644
--- a/sources/shiboken6/tests/libother/CMakeLists.txt
+++ b/sources/shiboken6/tests/libother/CMakeLists.txt
@@ -1,12 +1,17 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(libother)
 
 set(libother_SRC
-number.cpp
-otherderived.cpp
-otherobjecttype.cpp
-othermultiplederived.cpp
-smartptrtester.cpp
-othertypesystypedef.cpp
+extendsnoimplicitconversion.h
+libothermacros.h
+number.cpp number.h
+otherderived.cpp otherderived.h
+othermultiplederived.cpp othermultiplederived.h
+otherobjecttype.cpp otherobjecttype.h
+othertypesystypedef.cpp othertypesystypedef.h
+smartptrtester.cpp smartptrtester.h
 )
 
 add_library(libother SHARED ${libother_SRC})
diff --git a/sources/shiboken6/tests/libother/extendsnoimplicitconversion.h b/sources/shiboken6/tests/libother/extendsnoimplicitconversion.h
index bf6cd736c..36d503fe8 100644
--- a/sources/shiboken6/tests/libother/extendsnoimplicitconversion.h
+++ b/sources/shiboken6/tests/libother/extendsnoimplicitconversion.h
@@ -13,8 +13,9 @@ public:
     explicit ExtendsNoImplicitConversion(int objId) : m_objId(objId) {};
     inline int objId() const { return m_objId; }
     inline operator NoImplicitConversion() const { return NoImplicitConversion(m_objId); }
+
 private:
     int m_objId;
 };
-#endif // EXTENDSNOIMPLICITCONVERSION_H
 
+#endif // EXTENDSNOIMPLICITCONVERSION_H
diff --git a/sources/shiboken6/tests/libother/number.cpp b/sources/shiboken6/tests/libother/number.cpp
index c21c7c086..fbf50dc4a 100644
--- a/sources/shiboken6/tests/libother/number.cpp
+++ b/sources/shiboken6/tests/libother/number.cpp
@@ -2,33 +2,27 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "number.h"
-#include <cstring>
-#include <sstream>
 
-using namespace std;
+#include <sstream>
 
-Str
-Number::toStr() const
+Str Number::toStr() const
 {
-    ostringstream in;
+    std::ostringstream in;
     in << m_value;
     return in.str().c_str();
 }
 
-Point
-operator*(const Point& p, const Number& n)
+Point operator*(const Point &p, const Number &n)
 {
-    return Point(p.x() * n.value(), p.y() * n.value());
+    return {p.x() * n.value(), p.y() * n.value()};
 }
 
-Complex
-Number::toComplex() const
+Complex Number::toComplex() const
 {
     return Complex(m_value);
 }
 
-Number
-Number::fromComplex(Complex cpx)
+Number Number::fromComplex(Complex cpx)
 {
     return Number(cpx.real());
 }
diff --git a/sources/shiboken6/tests/libother/number.h b/sources/shiboken6/tests/libother/number.h
index 85f888d82..2c480e7f2 100644
--- a/sources/shiboken6/tests/libother/number.h
+++ b/sources/shiboken6/tests/libother/number.h
@@ -18,7 +18,7 @@ public:
     Str toStr() const;
     inline operator Str() const { return toStr(); }
 
-    friend LIBOTHER_API Point operator*(const Point&, const Number&);
+    friend LIBOTHER_API Point operator*(const Point &, const Number &);
 
     Complex toComplex() const;
     static Number fromComplex(Complex cpx);
@@ -27,6 +27,6 @@ private:
     int m_value;
 };
 
-LIBOTHER_API Point operator*(const Point&, const Number&);
+LIBOTHER_API Point operator*(const Point &, const Number &);
 
 #endif // NUMBER_H
diff --git a/sources/shiboken6/tests/libother/otherderived.cpp b/sources/shiboken6/tests/libother/otherderived.cpp
index 12521b73c..93a18876e 100644
--- a/sources/shiboken6/tests/libother/otherderived.cpp
+++ b/sources/shiboken6/tests/libother/otherderived.cpp
@@ -7,30 +7,24 @@ OtherDerived::OtherDerived(int id) : Abstract(id)
 {
 }
 
-OtherDerived::~OtherDerived()
-{
-}
+OtherDerived::~OtherDerived() = default;
 
-Abstract*
-OtherDerived::createObject()
+Abstract *OtherDerived::createObject()
 {
     static int id = 100;
     return new OtherDerived(id++);
 }
 
-void
-OtherDerived::pureVirtual()
+void OtherDerived::pureVirtual()
 {
 }
 
-void*
-OtherDerived::pureVirtualReturningVoidPtr()
+void *OtherDerived::pureVirtualReturningVoidPtr()
 {
     return nullptr;
 }
 
-void
-OtherDerived::unpureVirtual()
+void OtherDerived::unpureVirtual()
 {
 }
 
diff --git a/sources/shiboken6/tests/libother/otherderived.h b/sources/shiboken6/tests/libother/otherderived.h
index cefb4dc11..d6bde8808 100644
--- a/sources/shiboken6/tests/libother/otherderived.h
+++ b/sources/shiboken6/tests/libother/otherderived.h
@@ -18,26 +18,26 @@ public:
     OtherDerived(int id = -1);
     ~OtherDerived() override;
     void pureVirtual() override;
-    void* pureVirtualReturningVoidPtr() override;
+    void *pureVirtualReturningVoidPtr() override;
     void unpureVirtual() override;
     PrintFormat returnAnEnum()  override { return Short; }
 
-    inline void useObjectTypeFromOtherModule(ObjectType*) {}
-    inline Event useValueTypeFromOtherModule(const Event& e) { return e; }
-    inline Complex useValueTypeFromOtherModule(const Complex& c) { return c; }
+    inline void useObjectTypeFromOtherModule(ObjectType *) {}
+    inline Event useValueTypeFromOtherModule(const Event &e) { return e; }
+    inline Complex useValueTypeFromOtherModule(const Complex &c) { return c; }
     inline void useEnumTypeFromOtherModule(OverloadedFuncEnum) {}
 
     // factory method
-    static Abstract* createObject();
+    static Abstract *createObject();
 
     void hideFunction(HideType*) override {}
 
 protected:
-    inline const char* getClassName() { return className(); }
-    virtual const char* className()  override { return "OtherDerived"; }
+    inline const char *getClassName() { return className(); }
+    const char *className() const override { return "OtherDerived"; }
 
 private:
     void pureVirtualPrivate() override;
 };
-#endif // OTHERDERIVED_H
 
+#endif // OTHERDERIVED_H
diff --git a/sources/shiboken6/tests/libother/othermultiplederived.cpp b/sources/shiboken6/tests/libother/othermultiplederived.cpp
index 41718fc49..cfbbfb2c2 100644
--- a/sources/shiboken6/tests/libother/othermultiplederived.cpp
+++ b/sources/shiboken6/tests/libother/othermultiplederived.cpp
@@ -8,18 +8,17 @@ VirtualMethods OtherMultipleDerived::returnUselessClass()
     return VirtualMethods();
 }
 
-Base1* OtherMultipleDerived::createObject(const std::string& objName)
+Base1 *OtherMultipleDerived::createObject(const std::string &objName)
 {
     if (objName == "Base1")
         return new Base1;
-    else if (objName == "MDerived1")
+    if (objName == "MDerived1")
         return new MDerived1;
-    else if (objName == "SonOfMDerived1")
+    if (objName == "SonOfMDerived1")
         return new SonOfMDerived1;
-    else if (objName == "MDerived3")
+    if (objName == "MDerived3")
         return new MDerived3;
-    else if (objName == "OtherMultipleDerived")
+    if (objName == "OtherMultipleDerived")
         return new OtherMultipleDerived;
     return nullptr;
 }
-
diff --git a/sources/shiboken6/tests/libother/othermultiplederived.h b/sources/shiboken6/tests/libother/othermultiplederived.h
index c209c72ac..cd9910687 100644
--- a/sources/shiboken6/tests/libother/othermultiplederived.h
+++ b/sources/shiboken6/tests/libother/othermultiplederived.h
@@ -10,12 +10,12 @@
 
 class ObjectType;
 
-class LIBOTHER_API OtherMultipleDerived : public MDerived1
+class LIBOTHER_API OtherMultipleDerived : public OtherBase, public MDerived1
 {
 public:
     // this will use CppCopier from other module (bug#142)
     VirtualMethods returnUselessClass();
-    static Base1* createObject(const std::string& objName);
+    static Base1 *createObject(const std::string &objName);
 };
 
-#endif
+#endif // OTHERMULTIPLEDERIVED_H
diff --git a/sources/shiboken6/tests/libother/otherobjecttype.cpp b/sources/shiboken6/tests/libother/otherobjecttype.cpp
index fee6f5bfa..eaaa231be 100644
--- a/sources/shiboken6/tests/libother/otherobjecttype.cpp
+++ b/sources/shiboken6/tests/libother/otherobjecttype.cpp
@@ -3,10 +3,9 @@
 
 #include "otherobjecttype.h"
 
-Collector&
-operator<<(Collector& collector, const OtherObjectType& obj)
+Collector &operator<<(Collector &collector, const OtherObjectType &obj)
 {
-    collector << obj.identifier()*2;
+    collector << obj.identifier() * 2;
     return collector;
 }
 
diff --git a/sources/shiboken6/tests/libother/otherobjecttype.h b/sources/shiboken6/tests/libother/otherobjecttype.h
index b301ce22b..844795118 100644
--- a/sources/shiboken6/tests/libother/otherobjecttype.h
+++ b/sources/shiboken6/tests/libother/otherobjecttype.h
@@ -4,16 +4,12 @@
 #ifndef OTHEROBJECTTYPE_H
 #define OTHEROBJECTTYPE_H
 
-#include <list>
-#include "str.h"
-
 #include "libothermacros.h"
 #include "objecttype.h"
 #include "collector.h"
 #include "samplenamespace.h"
 #include "removednamespaces.h"
 
-
 class LIBOTHER_API OtherObjectType : public ObjectType
 {
 public:
@@ -21,8 +17,6 @@ public:
     static int enumAsIntForInvisibleNamespace(RemovedNamespace1::RemovedNamespace1_Enum value);
 };
 
-
-LIBOTHER_API Collector& operator<<(Collector&, const OtherObjectType&);
+LIBOTHER_API Collector &operator<<(Collector &, const OtherObjectType &);
 
 #endif // OTHEROBJECTTYPE_H
-
diff --git a/sources/shiboken6/tests/libother/smartptrtester.cpp b/sources/shiboken6/tests/libother/smartptrtester.cpp
index 25b6a406e..1c6496b1a 100644
--- a/sources/shiboken6/tests/libother/smartptrtester.cpp
+++ b/sources/shiboken6/tests/libother/smartptrtester.cpp
@@ -5,7 +5,7 @@
 
 SharedPtr<Str> SmartPtrTester::createSharedPtrStr(const char *what)
 {
-    return SharedPtr<Str>(new Str(what));
+    return {new Str(what)};
 }
 
 std::string SmartPtrTester::valueOfSharedPtrStr(const SharedPtr<Str> &str)
diff --git a/sources/shiboken6/tests/libsample/CMakeLists.txt b/sources/shiboken6/tests/libsample/CMakeLists.txt
index 6e436ee1f..926972340 100644
--- a/sources/shiboken6/tests/libsample/CMakeLists.txt
+++ b/sources/shiboken6/tests/libsample/CMakeLists.txt
@@ -1,63 +1,93 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(libsample)
 
 set(libsample_SRC
-abstract.cpp
-blackbox.cpp
-bytearray.cpp
-bucket.cpp
-collector.cpp
-complex.cpp
-ctparam.cpp
-onlycopy.cpp
-derived.cpp
-derivedusingct.cpp
-echo.cpp
-exceptiontest.cpp
-functions.cpp
-handle.cpp
-implicitconv.cpp
-intwrapper.cpp
-injectcode.cpp
-listuser.cpp
-modifications.cpp
-mapuser.cpp
-modified_constructor.cpp
-multiple_derived.cpp
-oddbool.cpp
-objectmodel.cpp
-objecttype.cpp
-objecttypeholder.cpp
-objecttypelayout.cpp
-objecttypeoperators.cpp
-objectview.cpp
-overload.cpp
-overloadsort.cpp
-pairuser.cpp
-pen.cpp
-photon.cpp
-point.cpp
-pointf.cpp
-polygon.cpp
-protected.cpp
-reference.cpp
-renaming.cpp
-sample.cpp
-samplenamespace.cpp
-sbkdate.cpp
-simplefile.cpp
-size.cpp
-snakecasetest.cpp
-sometime.cpp
-str.cpp
-strlist.cpp
-templateptr.cpp
-transform.cpp
-typesystypedef.cpp
-virtualmethods.cpp
-expression.cpp
-filter.cpp
+abstract.cpp abstract.h
+blackbox.cpp blackbox.h
+bucket.cpp bucket.h
+bytearray.cpp bytearray.h
+collector.cpp collector.h
+complex.cpp complex.h
+ctorconvrule.h
+ctparam.cpp ctparam.h
+cvlist.h
+derived.cpp derived.h
+derivedusingct.cpp derivedusingct.h
+echo.cpp echo.h
+exceptiontest.cpp exceptiontest.h
+expression.cpp expression.h
+filter.cpp filter.h
+functions.cpp functions.h
+handle.cpp handle.h
+implicitconv.cpp implicitconv.h
+injectcode.cpp injectcode.h
+intwrapper.cpp intwrapper.h
+libsamplemacros.h
+list.h
+listuser.cpp listuser.h
+mapuser.cpp mapuser.h
+modelindex.h
+modifications.cpp modifications.h
+modified_constructor.cpp modified_constructor.h
+multiple_derived.cpp multiple_derived.h
+noimplicitconversion.h
+nondefaultctor.h
+nontypetemplate.h
+null.h
+objectmodel.cpp objectmodel.h
+objecttype.cpp objecttype.h
+objecttypebyvalue.h
+objecttypeholder.cpp objecttypeholder.h
+objecttypelayout.cpp objecttypelayout.h
+objecttypeoperators.cpp objecttypeoperators.h
+objectview.cpp objectview.h
+oddbool.cpp oddbool.h
+onlycopy.cpp onlycopy.h
+overload.cpp overload.h
+overloadsort.cpp overloadsort.h
+pairuser.cpp pairuser.h
+pen.cpp pen.h
+photon.cpp photon.h
+point.cpp point.h
+pointerholder.h
+pointf.cpp pointf.h
+polygon.cpp polygon.h
+privatector.h
+privatedtor.h
+protected.cpp protected.h
+rect.h
+reference.cpp reference.h
+removednamespaces.h
+renaming.cpp renaming.h
+sample.cpp sample.h
+samplenamespace.cpp samplenamespace.h
+sbkdate.cpp sbkdate.h
+stdcomplex.cpp stdcomplex.h
+simplefile.cpp simplefile.h
+size.cpp size.h
+snakecasetest.cpp snakecasetest.h
+sometime.cpp sometime.h
+str.cpp str.h
+strlist.cpp strlist.h
+templateptr.cpp templateptr.h
+transform.cpp transform.h
+typesystypedef.cpp typesystypedef.h
+valueandvirtual.h
+virtualmethods.cpp virtualmethods.h
+voidholder.h
 )
 
+# Includes windows.h which is causing clashes between class Polygon and
+# wingdi.h's Polygon() function.
+
+if(WIN32)
+    set_source_files_properties(
+        bucket.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON
+    )
+endif()
+
 add_library(libsample SHARED ${libsample_SRC})
 target_include_directories(libsample PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 target_compile_definitions(libsample PRIVATE LIBSAMPLE_BUILD)
diff --git a/sources/shiboken6/tests/libsample/abstract.cpp b/sources/shiboken6/tests/libsample/abstract.cpp
index 7d4a21ceb..0d67d8630 100644
--- a/sources/shiboken6/tests/libsample/abstract.cpp
+++ b/sources/shiboken6/tests/libsample/abstract.cpp
@@ -1,64 +1,64 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
 #include "abstract.h"
-#include "objecttype.h"
 
-using namespace std;
+#include <iostream>
 
 const int Abstract::staticPrimitiveField = 0;
 
-Abstract::Abstract(int id) : m_id(id)
+Abstract::Abstract(int id) noexcept : m_id(id)
 {
-    toBeRenamedField = readOnlyField = primitiveField = 123;
-    valueTypeField = Point(12, 34);
-    objectTypeField = nullptr;
     bitField = 0;
 }
 
-Abstract::~Abstract()
-{
-}
+Abstract::~Abstract() = default;
 
-void
-Abstract::unpureVirtual()
+void Abstract::unpureVirtual()
 {
 }
 
-void
-Abstract::callUnpureVirtual()
+void Abstract::callUnpureVirtual()
 {
     this->unpureVirtual();
 }
 
-
-void
-Abstract::callPureVirtual()
+void Abstract::callPureVirtual()
 {
     this->pureVirtual();
 }
 
-void
-Abstract::show(PrintFormat format)
+void Abstract::show(PrintFormat format) const
 {
-    cout << '<';
+    std::cout << '<';
     switch(format) {
-        case Short:
-            cout << this;
-            break;
-        case Verbose:
-            cout << "class " << className() << " | cptr: " << this;
-            cout << ", id: " << m_id;
-            break;
-        case OnlyId:
-            cout << "id: " << m_id;
-            break;
-        case ClassNameAndId:
-            cout << className() << " - id: " << m_id;
-            break;
+    case Short:
+        std::cout << this;
+        break;
+    case Verbose:
+        std::cout << "class " << className() << " | cptr: " << this
+                  << ", id: " << m_id;
+        break;
+    case OnlyId:
+        std::cout << "id: " << m_id;
+        break;
+    case ClassNameAndId:
+        std::cout << className() << " - id: " << m_id;
+        break;
     }
-    cout << '>';
+    std::cout << '>';
+}
+
+void Abstract::virtualWithOutParameter(int &x) const
+{
+    x = 42;
+}
+
+int Abstract::callVirtualWithOutParameter() const
+{
+    int x;
+    virtualWithOutParameter(x);
+    return x;
 }
 
 void Abstract::callVirtualGettingEnum(PrintFormat p)
@@ -69,4 +69,3 @@ void Abstract::callVirtualGettingEnum(PrintFormat p)
 void Abstract::virtualGettingAEnum(Abstract::PrintFormat)
 {
 }
-
diff --git a/sources/shiboken6/tests/libsample/abstract.h b/sources/shiboken6/tests/libsample/abstract.h
index 0e66ad0e1..4c1b98d90 100644
--- a/sources/shiboken6/tests/libsample/abstract.h
+++ b/sources/shiboken6/tests/libsample/abstract.h
@@ -24,6 +24,8 @@ private:
         PrivValue2 = PrivValue1 + 2
     };
 public:
+    LIBMINIMAL_DISABLE_COPY_MOVE(Abstract)
+
     enum PrintFormat {
         Short,
         Verbose,
@@ -38,26 +40,26 @@ public:
     };
 
     static const int staticPrimitiveField;
-    int primitiveField;
+    int primitiveField = 123;
     Complex userPrimitiveField;
-    Point valueTypeField;
-    ObjectType* objectTypeField;
-    int toBeRenamedField;
-    int readOnlyField;
+    Point valueTypeField{12, 34};
+    ObjectType *objectTypeField = nullptr;
+    int toBeRenamedField = 123;
+    int readOnlyField = 123;
 
-    Abstract(int id = -1);
+    explicit Abstract(int id = -1) noexcept;
     virtual ~Abstract();
 
-    inline int id() { return m_id; }
+    inline int id() const { return m_id; }
 
     // factory method
-    inline static Abstract* createObject() { return nullptr; }
+    inline static Abstract *createObject() { return nullptr; }
 
     // method that receives an Object Type
-    inline static int getObjectId(Abstract* obj) { return obj->id(); }
+    inline static int getObjectId(Abstract *obj) { return obj->id(); }
 
     virtual void pureVirtual() = 0;
-    virtual void* pureVirtualReturningVoidPtr() = 0;
+    virtual void *pureVirtualReturningVoidPtr() = 0;
     virtual void unpureVirtual();
 
     virtual PrintFormat returnAnEnum() = 0;
@@ -67,13 +69,16 @@ public:
     void callPureVirtual();
     void callUnpureVirtual();
 
-    void show(PrintFormat format = Verbose);
+    void show(PrintFormat format = Verbose) const;
     virtual Type type() const { return TpAbstract; }
 
-    virtual void hideFunction(HideType* arg) = 0;
+    virtual void hideFunction(HideType *arg) = 0;
+
+    virtual void virtualWithOutParameter(int &x) const;
+    int callVirtualWithOutParameter() const;
 
 protected:
-    virtual const char* className() { return "Abstract"; }
+    virtual const char *className() const { return "Abstract"; }
 
     // Protected bit-field structure member.
     unsigned int bitField: 1;
@@ -82,4 +87,5 @@ private:
     virtual void pureVirtualPrivate() = 0;
     int m_id;
 };
+
 #endif // ABSTRACT_H
diff --git a/sources/shiboken6/tests/libsample/blackbox.cpp b/sources/shiboken6/tests/libsample/blackbox.cpp
index f648a3770..2ac435d3d 100644
--- a/sources/shiboken6/tests/libsample/blackbox.cpp
+++ b/sources/shiboken6/tests/libsample/blackbox.cpp
@@ -3,102 +3,79 @@
 
 #include "blackbox.h"
 
-using namespace std;
-
 BlackBox::~BlackBox()
 {
     // Free all maps.
-    while (!m_objects.empty()) {
-        delete (*m_objects.begin()).second;
-        m_objects.erase(m_objects.begin());
-    }
-    while (!m_points.empty()) {
-        delete (*m_points.begin()).second;
-        m_points.erase(m_points.begin());
-    }
+    for (const auto &p :m_objects)
+        delete p.second;
+    for (const auto &p : m_points)
+        delete p.second;
 }
 
-int
-BlackBox::keepObjectType(ObjectType* object)
+int BlackBox::keepObjectType(ObjectType *object)
 {
-    m_ticket++;
-    std::pair<int, ObjectType*> item(m_ticket, object);
-    m_objects.insert(item);
+    ++m_ticket;
+    m_objects.insert({m_ticket, object});
     object->setParent(nullptr);
 
     return m_ticket;
 }
 
-ObjectType*
-BlackBox::retrieveObjectType(int ticket)
+ObjectType *BlackBox::retrieveObjectType(int ticket)
 {
     const auto it = m_objects.find(ticket);
     if (it != m_objects.end()) {
-        ObjectType* second = it->second;
+        ObjectType *second = it->second;
         m_objects.erase(it);
         return second;
     }
     return nullptr;
 }
 
-void
-BlackBox::disposeObjectType(int ticket)
+void BlackBox::disposeObjectType(int ticket)
 {
-    ObjectType* object = retrieveObjectType(ticket);
-    if (object)
-        delete object;
+    delete retrieveObjectType(ticket);
 }
 
-int
-BlackBox::keepPoint(Point* point)
+int BlackBox::keepPoint(Point *point)
 {
-    m_ticket++;
-    std::pair<int, Point*> item(m_ticket, point);
-    m_points.insert(item);
-
+    ++m_ticket;
+    m_points.insert({m_ticket, point});
     return m_ticket;
 }
 
-Point*
-BlackBox::retrievePoint(int ticket)
+Point *BlackBox::retrievePoint(int ticket)
 {
     const auto it = m_points.find(ticket);
     if (it != m_points.end()) {
-        Point* second = it->second;
+        Point *second = it->second;
         m_points.erase(it);
         return second;
     }
     return nullptr;
 }
 
-void
-BlackBox::disposePoint(int ticket)
+void BlackBox::disposePoint(int ticket)
 {
-    Point* point = retrievePoint(ticket);
-    if (point)
-        delete point;
+    delete retrievePoint(ticket);
 }
 
-
-std::list<ObjectType*>
-BlackBox::objects()
+std::list<ObjectType*> BlackBox::objects()
 {
     std::list<ObjectType*> l;
 
-    for (auto it = m_objects.begin(), end = m_objects.end(); it != end; ++it)
-        l.push_back((*it).second);
+    for (const auto &p : m_objects)
+        l.push_back(p.second);
 
     return l;
 }
 
-std::list<Point*>
-BlackBox::points()
+std::list<Point*> BlackBox::points()
 {
     std::list<Point*> l;
 
-    for (auto it = m_points.begin(), end = m_points.end(); it != end; ++it)
-        l.push_back((*it).second);
+    for (const auto &p : m_points)
+        l.push_back(p.second);
 
     return l;
 }
-
diff --git a/sources/shiboken6/tests/libsample/blackbox.h b/sources/shiboken6/tests/libsample/blackbox.h
index bfcbd2128..9d32670dd 100644
--- a/sources/shiboken6/tests/libsample/blackbox.h
+++ b/sources/shiboken6/tests/libsample/blackbox.h
@@ -5,25 +5,28 @@
 #define BLACKBOX_H
 
 #include "libsamplemacros.h"
-#include <map>
 #include "objecttype.h"
 #include "point.h"
 
+#include <list>
+#include <map>
+
 class LIBSAMPLE_API BlackBox
 {
 public:
-    typedef std::map<int, ObjectType*> ObjectTypeMap;
-    typedef std::map<int, Point*> PointMap;
+    using ObjectTypeMap = std::map<int, ObjectType*>;
+    using PointMap = std::map<int, Point*>;
 
-    BlackBox() { m_ticket = -1;}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(BlackBox)
+    BlackBox() noexcept = default;
     ~BlackBox();
 
-    int keepObjectType(ObjectType* object);
-    ObjectType* retrieveObjectType(int ticket);
+    int keepObjectType(ObjectType *object);
+    ObjectType *retrieveObjectType(int ticket);
     void disposeObjectType(int ticket);
 
-    int keepPoint(Point* point);
-    Point* retrievePoint(int ticket);
+    int keepPoint(Point *point);
+    Point *retrievePoint(int ticket);
     void disposePoint(int ticket);
 
     std::list<ObjectType*> objects();
@@ -35,8 +38,7 @@ public:
 private:
     ObjectTypeMap m_objects;
     PointMap m_points;
-    int m_ticket;
+    int m_ticket = -1;
 };
 
 #endif // BLACKBOX_H
-
diff --git a/sources/shiboken6/tests/libsample/bucket.cpp b/sources/shiboken6/tests/libsample/bucket.cpp
index 01a1f591e..cafd382a9 100644
--- a/sources/shiboken6/tests/libsample/bucket.cpp
+++ b/sources/shiboken6/tests/libsample/bucket.cpp
@@ -2,23 +2,20 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "bucket.h"
+
 #include <iostream>
 
 #ifdef _WIN32 // _WIN32 is defined by all Windows 32 and 64 bit compilers, but not by others.
-#include <windows.h>
-#define SLEEP(x) Sleep(x)
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  define SLEEP(x) Sleep(x)
 #else
-#include <unistd.h>
-#define SLEEP(x) usleep(x)
+#  include <unistd.h>
+#  define SLEEP(x) usleep(x)
 #endif
 
-
-using namespace std;
-
-Bucket::Bucket() : m_locked(false)
-{
-}
-
 void Bucket::push(int x)
 {
     m_data.push_back(x);
@@ -28,7 +25,7 @@ int Bucket::pop(void)
 {
     int x = 0;
 
-    if (m_data.size() > 0) {
+    if (!m_data.empty()) {
         x = m_data.front();
         m_data.pop_front();
     }
@@ -44,7 +41,9 @@ bool Bucket::empty()
 void Bucket::lock()
 {
     m_locked = true;
-    while (m_locked) { SLEEP(300); }
+    while (m_locked) {
+        SLEEP(300);
+    }
 }
 
 void Bucket::unlock()
@@ -58,4 +57,3 @@ bool Bucket::virtualBlockerMethod()
     // The return value was added just for diversity sake.
     return true;
 }
-
diff --git a/sources/shiboken6/tests/libsample/bucket.h b/sources/shiboken6/tests/libsample/bucket.h
index 4a45802a4..73e8edd78 100644
--- a/sources/shiboken6/tests/libsample/bucket.h
+++ b/sources/shiboken6/tests/libsample/bucket.h
@@ -6,6 +6,7 @@
 
 #include "libsamplemacros.h"
 #include "objecttype.h"
+
 #include <list>
 
 class ObjectType;
@@ -13,7 +14,7 @@ class ObjectType;
 class LIBSAMPLE_API Bucket : public ObjectType
 {
 public:
-    Bucket();
+    Bucket() = default;
     void push(int);
     int pop();
     bool empty();
@@ -27,8 +28,7 @@ public:
 private:
     std::list<int> m_data;
 
-    volatile bool m_locked;
+    volatile bool m_locked = false;
 };
 
 #endif // BUCKET_H
-
diff --git a/sources/shiboken6/tests/libsample/bytearray.cpp b/sources/shiboken6/tests/libsample/bytearray.cpp
index 2ed80bf51..78d5162b0 100644
--- a/sources/shiboken6/tests/libsample/bytearray.cpp
+++ b/sources/shiboken6/tests/libsample/bytearray.cpp
@@ -1,13 +1,14 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <cstring>
 #include "bytearray.h"
 
-ByteArray::ByteArray()
+#include <algorithm>
+#include <iterator>
+#include <cstring>
+
+ByteArray::ByteArray() : m_data(1, '\0')
 {
-    m_data = std::vector<char>(1);
-    m_data[0] = '\0';
 }
 
 ByteArray::ByteArray(char c)
@@ -17,41 +18,37 @@ ByteArray::ByteArray(char c)
     m_data[1] = '\0';
 }
 
-ByteArray::ByteArray(const char* data)
+ByteArray::ByteArray(const char *data)
 {
-    size_t len = strlen(data);
+    size_t len = std::strlen(data);
     m_data = std::vector<char>(len + 1);
     memcpy(&m_data[0], data, len);
     m_data[len] = '\0';
 }
 
-ByteArray::ByteArray(const char* data, int len)
+ByteArray::ByteArray(const char *data, int len)
 {
     m_data = std::vector<char>(len + 1);
     memcpy(&m_data[0], data, len);
     m_data[len] = '\0';
 }
 
-int
-ByteArray::size() const
+int ByteArray::size() const
 {
     return m_data.size() - 1;
 }
 
-char
-ByteArray::at(int pos) const
+char ByteArray::at(int pos) const
 {
     return m_data[pos];
 }
 
-const char*
-ByteArray::data() const
+const char *ByteArray::data() const
 {
     return &(m_data[0]);
 }
 
-ByteArray&
-ByteArray::append(char c)
+ByteArray &ByteArray::append(char c)
 {
     m_data.pop_back();
     m_data.push_back(c);
@@ -59,37 +56,30 @@ ByteArray::append(char c)
     return *this;
 }
 
-ByteArray&
-ByteArray::append(const char* data)
+ByteArray &ByteArray::append(const char *data)
 {
     m_data.pop_back();
-    for (int i = 0; i < (int)strlen(data); ++i)
-        m_data.push_back(data[i]);
+    std::copy(data, data + strlen(data), std::back_inserter(m_data));
     m_data.push_back('\0');
     return *this;
 }
 
-ByteArray&
-ByteArray::append(const char* data, int len)
+ByteArray &ByteArray::append(const char *data, int len)
 {
     m_data.pop_back();
-    for (int i = 0; i < len; ++i)
-        m_data.push_back(data[i]);
+    std::copy(data, data + len, std::back_inserter(m_data));
     m_data.push_back('\0');
     return *this;
 }
 
-ByteArray&
-ByteArray::append(const ByteArray& other)
+ByteArray &ByteArray::append(const ByteArray &other)
 {
     m_data.pop_back();
-    for (int i = 0; i < (int)other.m_data.size(); ++i)
-        m_data.push_back(other.m_data[i]);
-    m_data.push_back('\0');
+    std::copy(other.m_data.begin(), other.m_data.end(), std::back_inserter(m_data));
     return *this;
 }
 
-static bool compare(const std::vector<char>& mine, const char* other)
+static bool compare(const std::vector<char> &mine, const char *other)
 {
     for (int i = 0; i < (int)mine.size() - 1; ++i) {
         if (mine[i] != other[i])
@@ -98,85 +88,79 @@ static bool compare(const std::vector<char>& mine, const char* other)
     return true;
 }
 
-bool
-ByteArray::operator==(const ByteArray& other) const
+bool ByteArray::operator==(const ByteArray &other) const
 {
-    return compare(m_data, &other.m_data[0]);
+    return m_data == other.m_data;
 }
-bool
-operator==(const ByteArray& ba1, const char* ba2)
+bool operator==(const ByteArray &ba1, const char *ba2)
 {
     return compare(ba1.m_data, ba2);
 }
-bool
-operator==(const char* ba1, const ByteArray& ba2)
+
+bool operator==(const char *ba1, const ByteArray &ba2)
 {
     return compare(ba2.m_data, ba1);
 }
 
-bool
-ByteArray::operator!=(const ByteArray& other) const
+bool ByteArray::operator!=(const ByteArray &other) const
 {
-    return !(m_data == other.m_data);
+    return m_data != other.m_data;
 }
-bool
-operator!=(const ByteArray& ba1, const char* ba2)
+
+bool operator!=(const ByteArray &ba1, const char *ba2)
 {
     return !(ba1 == ba2);
 }
-bool
-operator!=(const char* ba1, const ByteArray& ba2)
+
+bool operator!=(const char *ba1, const ByteArray &ba2)
 {
     return !(ba1 == ba2);
 }
 
-ByteArray&
-ByteArray::operator+=(char c)
+ByteArray &ByteArray::operator+=(char c)
 {
     return append(c);
 }
-ByteArray&
-ByteArray::operator+=(const char* data)
+
+ByteArray &ByteArray::operator+=(const char *data)
 {
     return append(data);
 }
-ByteArray&
-ByteArray::operator+=(const ByteArray& other)
+
+ByteArray &ByteArray::operator+=(const ByteArray &other)
 {
     return append(other);
 }
 
-ByteArray
-operator+(const ByteArray& ba1, const ByteArray& ba2)
+ByteArray operator+(const ByteArray &ba1, const ByteArray &ba2)
 {
     return ByteArray(ba1) += ba2;
 }
-ByteArray
-operator+(const ByteArray& ba1, const char* ba2)
+
+ByteArray operator+(const ByteArray &ba1, const char *ba2)
 {
     return ByteArray(ba1) += ByteArray(ba2);
 }
-ByteArray
-operator+(const char* ba1, const ByteArray& ba2)
+
+ByteArray operator+(const char *ba1, const ByteArray &ba2)
 {
     return ByteArray(ba1) += ba2;
 }
-ByteArray
-operator+(const ByteArray& ba1, char ba2)
+
+ByteArray operator+(const ByteArray &ba1, char ba2)
 {
     return ByteArray(ba1) += ByteArray(ba2);
 }
-ByteArray
-operator+(char ba1, const ByteArray& ba2)
+
+ByteArray operator+(char ba1, const ByteArray &ba2)
 {
     return ByteArray(ba1) += ba2;
 }
 
-unsigned int
-ByteArray::hash(const ByteArray& byteArray)
+unsigned int ByteArray::hash(const ByteArray &byteArray)
 {
     unsigned int result = 0;
-    for (int i = 0; i < (int)byteArray.m_data.size(); ++i)
-        result = 5 * result + byteArray.m_data[i];
+    for (char c : byteArray.m_data)
+        result = 5U * result + unsigned(c);
     return result;
 }
diff --git a/sources/shiboken6/tests/libsample/bytearray.h b/sources/shiboken6/tests/libsample/bytearray.h
index e4504d755..35ff22367 100644
--- a/sources/shiboken6/tests/libsample/bytearray.h
+++ b/sources/shiboken6/tests/libsample/bytearray.h
@@ -6,58 +6,59 @@
 
 #include "str.h"
 #include "libsamplemacros.h"
+
 #include <vector>
 
 class LIBSAMPLE_API ByteArray
 {
 public:
     ByteArray();
-    ByteArray(char data);
-    ByteArray(const char* data);
-    ByteArray(const char* data, int len);
+    explicit ByteArray(char data);
+    explicit ByteArray(const char *data);
+    explicit ByteArray(const char *data, int len);
 
     int size() const;
     char at(int i) const;
     char operator[](int i) const;
 
-    const char* data() const;
+    const char *data() const;
 
-    ByteArray& append(char c);
-    ByteArray& append(const char* data);
-    ByteArray& append(const char* data, int len);
-    ByteArray& append(const ByteArray& other);
+    ByteArray &append(char c);
+    ByteArray &append(const char *data);
+    ByteArray &append(const char *data, int len);
+    ByteArray &append(const ByteArray &other);
 
-    bool operator==(const ByteArray& other) const;
-    bool operator!=(const ByteArray& other) const;
+    bool operator==(const ByteArray &other) const;
+    bool operator!=(const ByteArray &other) const;
 
-    ByteArray& operator+=(char c);
-    ByteArray& operator+=(const char* data);
-    ByteArray& operator+=(const ByteArray& other);
+    ByteArray &operator+=(char c);
+    ByteArray &operator+=(const char *data);
+    ByteArray &operator+=(const ByteArray &other);
 
-    static unsigned int hash(const ByteArray& byteArray);
+    static unsigned int hash(const ByteArray &byteArray);
 private:
     std::vector<char> m_data;
-    friend LIBSAMPLE_API bool operator==(const ByteArray& ba1, const char* ba2);
-    friend LIBSAMPLE_API bool operator==(const char* ba1, const ByteArray& ba2);
-    friend LIBSAMPLE_API bool operator!=(const ByteArray& ba1, const char* ba2);
-    friend LIBSAMPLE_API bool operator!=(const char* ba1, const ByteArray& ba2);
-
-    friend LIBSAMPLE_API ByteArray operator+(const ByteArray& ba1, const ByteArray& ba2);
-    friend LIBSAMPLE_API ByteArray operator+(const ByteArray& ba1, const char* ba2);
-    friend LIBSAMPLE_API ByteArray operator+(const char* ba1, const ByteArray& ba2);
-    friend LIBSAMPLE_API ByteArray operator+(const ByteArray& ba1, char ba2);
-    friend LIBSAMPLE_API ByteArray operator+(char ba1, const ByteArray& ba2);
+    friend LIBSAMPLE_API bool operator==(const ByteArray &ba1, const char *ba2);
+    friend LIBSAMPLE_API bool operator==(const char *ba1, const ByteArray &ba2);
+    friend LIBSAMPLE_API bool operator!=(const ByteArray &ba1, const char *ba2);
+    friend LIBSAMPLE_API bool operator!=(const char *ba1, const ByteArray &ba2);
+
+    friend LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, const ByteArray &ba2);
+    friend LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, const char *ba2);
+    friend LIBSAMPLE_API ByteArray operator+(const char *ba1, const ByteArray &ba2);
+    friend LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, char ba2);
+    friend LIBSAMPLE_API ByteArray operator+(char ba1, const ByteArray &ba2);
 };
 
-LIBSAMPLE_API bool operator==(const ByteArray& ba1, const char* ba2);
-LIBSAMPLE_API bool operator==(const char* ba1, const ByteArray& ba2);
-LIBSAMPLE_API bool operator!=(const ByteArray& ba1, const char* ba2);
-LIBSAMPLE_API bool operator!=(const char* ba1, const ByteArray& ba2);
+LIBSAMPLE_API bool operator==(const ByteArray &ba1, const char *ba2);
+LIBSAMPLE_API bool operator==(const char *ba1, const ByteArray &ba2);
+LIBSAMPLE_API bool operator!=(const ByteArray &ba1, const char *ba2);
+LIBSAMPLE_API bool operator!=(const char *ba1, const ByteArray &ba2);
 
-LIBSAMPLE_API ByteArray operator+(const ByteArray& ba1, const ByteArray& ba2);
-LIBSAMPLE_API ByteArray operator+(const ByteArray& ba1, const char* ba2);
-LIBSAMPLE_API ByteArray operator+(const char* ba1, const ByteArray& ba2);
-LIBSAMPLE_API ByteArray operator+(const ByteArray& ba1, char ba2);
-LIBSAMPLE_API ByteArray operator+(char ba1, const ByteArray& ba2);
+LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, const ByteArray &ba2);
+LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, const char *ba2);
+LIBSAMPLE_API ByteArray operator+(const char *ba1, const ByteArray &ba2);
+LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, char ba2);
+LIBSAMPLE_API ByteArray operator+(char ba1, const ByteArray &ba2);
 
 #endif // BYTEARRAY_H
diff --git a/sources/shiboken6/tests/libsample/collector.cpp b/sources/shiboken6/tests/libsample/collector.cpp
index 2adff6628..579239bcb 100644
--- a/sources/shiboken6/tests/libsample/collector.cpp
+++ b/sources/shiboken6/tests/libsample/collector.cpp
@@ -8,13 +8,13 @@ void Collector::clear()
     m_items.clear();
 }
 
-Collector& Collector::operator<<(ObjectType::Identifier item)
+Collector &Collector::operator<<(ObjectType::Identifier item)
 {
     m_items.push_back(item);
     return *this;
 }
 
-Collector& Collector::operator<<(const ObjectType *obj)
+Collector &Collector::operator<<(const ObjectType *obj)
 {
     m_items.push_back(obj->identifier());
     return *this;
@@ -25,9 +25,9 @@ std::list<ObjectType::Identifier> Collector::items()
     return m_items;
 }
 
-int Collector::size()
+int Collector::size() const
 {
-    return (int) m_items.size();
+    return int(m_items.size());
 }
 
 Collector &operator<<(Collector &s, const IntWrapper &w)
diff --git a/sources/shiboken6/tests/libsample/collector.h b/sources/shiboken6/tests/libsample/collector.h
index 1ef3281e5..26766847a 100644
--- a/sources/shiboken6/tests/libsample/collector.h
+++ b/sources/shiboken6/tests/libsample/collector.h
@@ -4,36 +4,34 @@
 #ifndef COLLECTOR_H
 #define COLLECTOR_H
 
-#include <list>
 #include "libsamplemacros.h"
-
 #include "intwrapper.h"
 #include "objecttype.h"
 
+#include <list>
+
 class LIBSAMPLE_API Collector
 {
 public:
-    Collector() {}
-    virtual ~Collector() {}
+    Collector() noexcept = default;
+    virtual ~Collector() = default;
+    LIBMINIMAL_DISABLE_COPY_MOVE(Collector)
 
     void clear();
 
-    Collector& operator<<(ObjectType::Identifier item);
+    Collector &operator<<(ObjectType::Identifier item);
 
-    Collector& operator<<(const ObjectType *);
+    Collector &operator<<(const ObjectType *);
 
     std::list<ObjectType::Identifier> items();
-    int size();
+    int size() const;
 
 private:
     std::list<ObjectType::Identifier> m_items;
-
-    Collector(const Collector&);
-    Collector& operator=(const Collector&);
 };
 
 /* Helper for testing external operators */
-LIBSAMPLE_API Collector &operator<<(Collector&, const IntWrapper&);
+LIBSAMPLE_API Collector &operator<<(Collector &, const IntWrapper &);
 
 #endif // COLLECTOR_H
 
diff --git a/sources/shiboken6/tests/libsample/complex.cpp b/sources/shiboken6/tests/libsample/complex.cpp
index ce2c2b7de..e3bec9aae 100644
--- a/sources/shiboken6/tests/libsample/complex.cpp
+++ b/sources/shiboken6/tests/libsample/complex.cpp
@@ -1,18 +1,16 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
 #include "complex.h"
 
-using namespace std;
+#include <iostream>
 
-Complex::Complex(double real, double imag)
+Complex::Complex(double real, double imag) noexcept
     : m_real(real), m_imag(imag)
 {
 }
 
-Complex
-Complex::operator+(Complex& other)
+Complex Complex::operator+(const Complex &other)
 {
     Complex result;
     result.setReal(m_real + other.real());
@@ -20,10 +18,7 @@ Complex::operator+(Complex& other)
     return result;
 }
 
-void
-Complex::show()
+void Complex::show() const
 {
-    cout << "(real: " << m_real << ", imag: " << m_imag << ")";
+    std::cout << "(real: " << m_real << ", imag: " << m_imag << ")";
 }
-
-
diff --git a/sources/shiboken6/tests/libsample/complex.h b/sources/shiboken6/tests/libsample/complex.h
index 54fb99ed1..168fe5c44 100644
--- a/sources/shiboken6/tests/libsample/complex.h
+++ b/sources/shiboken6/tests/libsample/complex.h
@@ -9,17 +9,19 @@
 class LIBSAMPLE_API Complex
 {
 public:
-    Complex(double real = 0.0, double imag = 0.0);
-    ~Complex() {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(Complex)
+
+    explicit Complex(double real = 0.0, double imag = 0.0) noexcept;
+    ~Complex() = default;
 
     inline double real() const { return m_real; }
     inline void setReal(double real) { m_real = real; }
     inline double imag() const { return m_imag; }
     inline void setImaginary(double imag) { m_imag = imag; }
 
-    Complex operator+(Complex& other);
+    Complex operator+(const Complex &other);
 
-    void show();
+    void show() const;
 
 private:
     double m_real;
diff --git a/sources/shiboken6/tests/libsample/ctorconvrule.h b/sources/shiboken6/tests/libsample/ctorconvrule.h
index cd7d1c669..a5411b749 100644
--- a/sources/shiboken6/tests/libsample/ctorconvrule.h
+++ b/sources/shiboken6/tests/libsample/ctorconvrule.h
@@ -9,8 +9,10 @@
 class CtorConvRule
 {
 public:
-    explicit CtorConvRule(long value) : m_value(value) {}
-    virtual ~CtorConvRule() {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(CtorConvRule)
+
+    explicit CtorConvRule(long value) noexcept : m_value(value) {}
+    virtual ~CtorConvRule() = default;
     virtual void dummyVirtualMethod() {}
     long value() { return m_value; }
 private:
diff --git a/sources/shiboken6/tests/libsample/cvlist.h b/sources/shiboken6/tests/libsample/cvlist.h
index eb635c83b..e09c7d943 100644
--- a/sources/shiboken6/tests/libsample/cvlist.h
+++ b/sources/shiboken6/tests/libsample/cvlist.h
@@ -12,7 +12,7 @@ class CVValueType
     CVValueType();
 };
 
-typedef std::list<const CVValueType*> const_ptr_value_list;
+using const_ptr_value_list = std::list<const CVValueType*>;
 
 // This tests binding generation for a container of a const value type. The
 // class doesn't need to do anything; this is just to verify that the generated
@@ -21,8 +21,8 @@ typedef std::list<const CVValueType*> const_ptr_value_list;
 class CVListUser
 {
 public:
-    static const_ptr_value_list produce() { return const_ptr_value_list(); }
-    static void consume(const const_ptr_value_list& l) { (void)l; }
+    static const_ptr_value_list produce() { return {}; }
+    static void consume(const const_ptr_value_list &l) { (void)l; }
 };
 
 #endif // LIST_H
diff --git a/sources/shiboken6/tests/libsample/derived.cpp b/sources/shiboken6/tests/libsample/derived.cpp
index 87a8669ff..d20880431 100644
--- a/sources/shiboken6/tests/libsample/derived.cpp
+++ b/sources/shiboken6/tests/libsample/derived.cpp
@@ -1,44 +1,36 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
 #include "derived.h"
 
-using namespace std;
+#include <iostream>
 
-Derived::Derived(int id) : Abstract(id)
+Derived::Derived(int id) noexcept : Abstract(id)
 {
 }
 
-Derived::~Derived()
-{
-}
+Derived::~Derived() = default;
 
-Abstract*
-Derived::createObject()
+Abstract *Derived::createObject()
 {
     static int id = 100;
     return new Derived(id++);
 }
 
-void
-Derived::pureVirtual()
+void Derived::pureVirtual()
 {
 }
 
-void*
-Derived::pureVirtualReturningVoidPtr()
+void *Derived::pureVirtualReturningVoidPtr()
 {
     return nullptr;
 }
 
-void
-Derived::unpureVirtual()
+void Derived::unpureVirtual()
 {
 }
 
-bool
-Derived::singleArgument(bool b)
+bool Derived::singleArgument(bool b)
 {
     return !b;
 }
@@ -70,15 +62,15 @@ Derived::OtherOverloadedFuncEnum Derived::otherOverloaded(int, double)
 }
 
 struct SecretClass : public Abstract {
-    virtual void pureVirtual() {}
-    virtual void *pureVirtualReturningVoidPtr() { return nullptr; }
-    virtual PrintFormat returnAnEnum() { return Short; }
-    void hideFunction(HideType*){};
+    void pureVirtual() override {}
+    void *pureVirtualReturningVoidPtr() override { return nullptr; }
+    PrintFormat returnAnEnum() override { return Short; }
+    void hideFunction(HideType*) override {};
 private:
-    virtual void pureVirtualPrivate() {}
+    void pureVirtualPrivate() override {}
 };
 
-Abstract* Derived::triggerImpossibleTypeDiscovery()
+Abstract *Derived::triggerImpossibleTypeDiscovery()
 {
     return new SecretClass;
 }
@@ -86,7 +78,7 @@ Abstract* Derived::triggerImpossibleTypeDiscovery()
 struct AnotherSecretClass : public Derived {
 };
 
-Abstract* Derived::triggerAnotherImpossibleTypeDiscovery()
+Abstract *Derived::triggerAnotherImpossibleTypeDiscovery()
 {
     return new AnotherSecretClass;
 }
diff --git a/sources/shiboken6/tests/libsample/derived.h b/sources/shiboken6/tests/libsample/derived.h
index 35673198b..cf95cb601 100644
--- a/sources/shiboken6/tests/libsample/derived.h
+++ b/sources/shiboken6/tests/libsample/derived.h
@@ -15,6 +15,8 @@ enum OverloadedFuncEnum {
 class LIBSAMPLE_API Derived : public Abstract
 {
 public:
+    LIBMINIMAL_DISABLE_COPY_MOVE(Derived)
+
     enum OtherOverloadedFuncEnum {
         OtherOverloadedFunc_iibd,
         OtherOverloadedFunc_id
@@ -23,21 +25,21 @@ public:
     class SomeInnerClass {
     public:
         void uselessMethod() {}
-        SomeInnerClass operator+(const SomeInnerClass& other) { return other; }
-        bool operator==(const SomeInnerClass &) { return true; }
+        SomeInnerClass operator+(const SomeInnerClass &other) { return other; }
+        bool operator==(const SomeInnerClass &) const { return true; }
     };
 
-    Derived(int id = -1);
+    explicit Derived(int id = -1) noexcept;
     ~Derived() override;
     void pureVirtual() override;
-    void* pureVirtualReturningVoidPtr() override;
+    void *pureVirtualReturningVoidPtr() override;
     void unpureVirtual() override;
 
     PrintFormat returnAnEnum()  override { return Short; }
     Type type() const override { return TpDerived; }
 
     // factory method
-    static Abstract* createObject();
+    static Abstract *createObject();
 
     // single argument
     bool singleArgument(bool b);
@@ -53,15 +55,15 @@ public:
     OtherOverloadedFuncEnum otherOverloaded(int a, int b, bool c, double d);
     OtherOverloadedFuncEnum otherOverloaded(int a, double b);
 
-    inline SomeInnerClass returnMyParameter(const SomeInnerClass& s) { return s; }
+    inline SomeInnerClass returnMyParameter(const SomeInnerClass &s) { return s; }
 
-    static Abstract* triggerImpossibleTypeDiscovery();
-    static Abstract* triggerAnotherImpossibleTypeDiscovery();
+    static Abstract *triggerImpossibleTypeDiscovery();
+    static Abstract *triggerAnotherImpossibleTypeDiscovery();
 
     void hideFunction(HideType*) override {}
 protected:
-    const char* getClassName() { return className(); }
-    virtual const char* className() override { return "Derived"; }
+    const char *getClassName() { return className(); }
+    virtual const char *className() const override { return "Derived"; }
 
 private:
     void pureVirtualPrivate() override;
diff --git a/sources/shiboken6/tests/libsample/echo.h b/sources/shiboken6/tests/libsample/echo.h
index 54db3e9bd..01b11a4a6 100644
--- a/sources/shiboken6/tests/libsample/echo.h
+++ b/sources/shiboken6/tests/libsample/echo.h
@@ -12,19 +12,21 @@ class ObjectType;
 class Echo
 {
 public:
-    Echo(){}
-    ~Echo(){}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(Echo)
+
+    Echo() noexcept = default;
+    ~Echo() = default;
 
     void doNothingWithConstBool(const bool hi);
-    void methodWithNamedArg(const Str& string = Str(""));
+    void methodWithNamedArg(const Str &string = Str{});
 
-    Str operator()(const Str& s, const int i) { return s + i; }
+    Str operator()(const Str &s, const int i) { return s + i; }
 
     // These method are here just for compilation test purposes
-    Echo& operator<<(unsigned int item);
-    Echo& operator<<(signed int item);
-    Echo& operator<<(const ObjectType *item);
-    Echo& operator<<(Str str);
+    Echo &operator<<(unsigned int item);
+    Echo &operator<<(signed int item);
+    Echo &operator<<(const ObjectType *item);
+    Echo &operator<<(Str str);
 };
 
 inline void Echo::doNothingWithConstBool(const bool)
diff --git a/sources/shiboken6/tests/libsample/expression.cpp b/sources/shiboken6/tests/libsample/expression.cpp
index 21a51a288..6f3c5fdc5 100644
--- a/sources/shiboken6/tests/libsample/expression.cpp
+++ b/sources/shiboken6/tests/libsample/expression.cpp
@@ -3,112 +3,77 @@
 
 
 #include "expression.h"
-#include <sstream>
-
-Expression::Expression() : m_value(0), m_operation(None), m_operand1(nullptr), m_operand2(nullptr)
-{
-}
-
-Expression::Expression(int number) : m_value(number), m_operation(None), m_operand1(nullptr), m_operand2(nullptr)
-{
-}
 
-Expression::Expression(const Expression& other)
-{
-    m_operand1 = other.m_operand1 ? new Expression(*other.m_operand1) : nullptr;
-    m_operand2 = other.m_operand2 ? new Expression(*other.m_operand2) : nullptr;
-    m_value = other.m_value;
-    m_operation = other.m_operation;
-}
+#include <sstream>
 
-Expression& Expression::operator=(const Expression& other)
-{
-    if (&other == this)
-        return *this;
-    delete m_operand1;
-    delete m_operand2;
-    m_operand1 = other.m_operand1 ? new Expression(*other.m_operand1) : nullptr;
-    m_operand2 = other.m_operand2 ? new Expression(*other.m_operand2) : nullptr;
-    m_operation = other.m_operation;
-    m_value = other.m_value;
-    return *this;
-}
+Expression::Expression() noexcept = default;
 
-Expression::~Expression()
+Expression::Expression(int number) noexcept : m_value(number)
 {
-    delete m_operand1;
-    delete m_operand2;
 }
 
-Expression Expression::operator+(const Expression& other)
+Expression Expression::operator+(const Expression &other)
 {
     Expression expr;
     expr.m_operation = Add;
-    expr.m_operand1 = new Expression(*this);
-    expr.m_operand2 = new Expression(other);
+    expr.m_operand1 = std::make_shared<Expression>(*this);
+    expr.m_operand2 = std::make_shared<Expression>(other);
     return expr;
 }
 
-Expression Expression::operator-(const Expression& other)
+Expression Expression::operator-(const Expression &other)
 {
     Expression expr;
     expr.m_operation = Add;
-    expr.m_operand1 = new Expression(*this);
-    expr.m_operand2 = new Expression(other);
+    expr.m_operand1 = std::make_shared<Expression>(*this);
+    expr.m_operand2 = std::make_shared<Expression>(other);
     return expr;
 }
 
-Expression Expression::operator<(const Expression& other)
+Expression Expression::operator<(const Expression &other)
 {
     Expression expr;
     expr.m_operation = LessThan;
-    expr.m_operand1 = new Expression(*this);
-    expr.m_operand2 = new Expression(other);
+    expr.m_operand1 = std::make_shared<Expression>(*this);
+    expr.m_operand2 = std::make_shared<Expression>(other);
     return expr;
 }
 
-Expression Expression::operator>(const Expression& other)
+Expression Expression::operator>(const Expression &other)
 {
     Expression expr;
     expr.m_operation = GreaterThan;
-    expr.m_operand1 = new Expression(*this);
-    expr.m_operand2 = new Expression(other);
+    expr.m_operand1 = std::make_shared<Expression>(*this);
+    expr.m_operand2 = std::make_shared<Expression>(other);
     return expr;
 }
 
 std::string Expression::toString() const
 {
+    std::ostringstream s;
     if (m_operation == None) {
-        std::ostringstream s;
         s << m_value;
         return s.str();
     }
 
-    std::string result;
-    result += '(';
-    result += m_operand1->toString();
-    char op;
+    s << '(' << m_operand1->toString();
     switch (m_operation) {
         case Add:
-            op = '+';
+            s << '+';
             break;
         case Sub:
-            op = '-';
+            s << '-';
             break;
         case LessThan:
-            op = '<';
+            s << '<';
             break;
         case GreaterThan:
-            op = '<';
+            s << '<';
             break;
-        case None: // just to avoid the compiler warning
         default:
-            op = '?';
+            s << '?';
             break;
     }
-    result += op;
-    result += m_operand2->toString();
-    result += ')';
-    return result;
+    s << m_operand2->toString() << ')';
+    return s.str();
 }
-
diff --git a/sources/shiboken6/tests/libsample/expression.h b/sources/shiboken6/tests/libsample/expression.h
index cf41cb620..e7c5b7306 100644
--- a/sources/shiboken6/tests/libsample/expression.h
+++ b/sources/shiboken6/tests/libsample/expression.h
@@ -6,34 +6,35 @@
 #define EXPRESSION_H
 
 #include "libsamplemacros.h"
+
+#include <memory>
 #include <string>
 
 class LIBSAMPLE_API Expression
 {
 public:
+    LIBMINIMAL_DEFAULT_COPY_MOVE(Expression)
+
     enum Operation {
         None, Add, Sub, LessThan, GreaterThan
     };
 
-    Expression(int number);
-    Expression(const Expression& other);
-    Expression& operator=(const Expression& other);
-
-    ~Expression();
+    explicit Expression(int number) noexcept;
+    ~Expression() = default;
 
-    Expression operator>(const Expression& other);
-    Expression operator<(const Expression& other);
-    Expression operator+(const Expression& other);
-    Expression operator-(const Expression& other);
+    Expression operator>(const Expression &other);
+    Expression operator<(const Expression &other);
+    Expression operator+(const Expression &other);
+    Expression operator-(const Expression &other);
 
     std::string toString() const;
 private:
-    int m_value;
-    Operation m_operation;
-    Expression* m_operand1;
-    Expression* m_operand2;
+    int m_value = 0;
+    Operation m_operation = None;
+    std::shared_ptr<Expression> m_operand1;
+    std::shared_ptr<Expression> m_operand2;
 
-    Expression();
+    Expression() noexcept;
 };
 
 #endif // EXPRESSION_H
diff --git a/sources/shiboken6/tests/libsample/filter.cpp b/sources/shiboken6/tests/libsample/filter.cpp
index 09c8c89ed..950847985 100644
--- a/sources/shiboken6/tests/libsample/filter.cpp
+++ b/sources/shiboken6/tests/libsample/filter.cpp
@@ -1,34 +1,34 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <string>
 #include "filter.h"
+
 Data::Data(Field field, std::string value)
     : m_field(field), m_value(value)
 {
 }
 
-Union::Union(const Data& filter)
+Union::Union(const Data &filter)
 {
     m_filters.push_back(filter);
 }
 
-Union::Union(const Intersection& filter)
+Union::Union(const Intersection &filter)
 {
     m_filters.push_back(filter);
 }
 
-Intersection::Intersection(const Data& filter)
+Intersection::Intersection(const Data &filter)
 {
     m_filters.push_back(filter);
 }
 
-Intersection::Intersection(const Union& filter)
+Intersection::Intersection(const Union &filter)
 {
     m_filters.push_back(filter);
 }
 
-Intersection operator&(const Intersection& a, const Intersection& b)
+Intersection operator&(const Intersection &a, const Intersection &b)
 {
     Intersection filter;
     filter.addFilter(a);
diff --git a/sources/shiboken6/tests/libsample/filter.h b/sources/shiboken6/tests/libsample/filter.h
index d778342ff..d82d38eb8 100644
--- a/sources/shiboken6/tests/libsample/filter.h
+++ b/sources/shiboken6/tests/libsample/filter.h
@@ -4,11 +4,11 @@
 #ifndef FILTER_H
 #define FILTER_H
 
+#include "libsamplemacros.h"
+
 #include <string>
 #include <list>
 
-#include "libsamplemacros.h"
-
 class Intersection;
 
 class LIBSAMPLE_API Filter
@@ -17,7 +17,6 @@ class LIBSAMPLE_API Filter
 
 class LIBSAMPLE_API Data : public Filter
 {
-
 public:
     enum Field {
         Name,
@@ -25,7 +24,7 @@ public:
         Year
     };
 
-    Data(Field field, std::string value);
+    explicit Data(Field field, std::string value);
 
     Field field() const { return m_field; }
     std::string value() const { return m_value; }
@@ -39,12 +38,12 @@ class LIBSAMPLE_API Union : public Filter
 {
 public:
 
-    Union(const Data&);
-    Union(const Intersection&);
+    Union(const Data &);
+    Union(const Intersection &);
     Union() = default;
 
     std::list<Filter> filters() const { return m_filters; }
-    void addFilter(const Filter& data) { m_filters.push_back(data); }
+    void addFilter(const Filter &data) { m_filters.push_back(data); }
 
 private:
     std::list<Filter> m_filters;
@@ -53,19 +52,18 @@ private:
 class LIBSAMPLE_API Intersection : public Filter
 {
 public:
-
-    Intersection(const Data&);
-    Intersection(const Union&);
+    Intersection(const Data &);
+    Intersection(const Union &);
     Intersection() = default;
 
     std::list<Filter> filters() const { return m_filters; }
-    void addFilter(const Filter& data) { m_filters.push_back(data); }
+    void addFilter(const Filter &data) { m_filters.push_back(data); }
 
 private:
     std::list<Filter> m_filters;
 };
 
-LIBSAMPLE_API Intersection operator&(const Intersection& a, const Intersection& b);
+LIBSAMPLE_API Intersection operator&(const Intersection &a, const Intersection &b);
 
 #endif // FILTER_H
 
diff --git a/sources/shiboken6/tests/libsample/functions.cpp b/sources/shiboken6/tests/libsample/functions.cpp
index d96a58abd..ad2f4dd5a 100644
--- a/sources/shiboken6/tests/libsample/functions.cpp
+++ b/sources/shiboken6/tests/libsample/functions.cpp
@@ -2,37 +2,33 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "functions.h"
-#include <string.h>
+#include "polygon.h"
+
+#include <cstring>
 #include <algorithm>
 #include <iostream>
 #include <numeric>
 
-using namespace std;
-
-void
-printSomething()
+void printSomething()
 {
-    cout << __FUNCTION__ << endl;
+    std::cout << __FUNCTION__ << std::endl;
 }
 
-int
-gimmeInt()
+int gimmeInt()
 {
     static int val = 2;
     val = val * 1.3;
     return val;
 }
 
-double
-gimmeDouble()
+double gimmeDouble()
 {
     static double val = 7.77;
     val = val * 1.3;
     return val;
 }
 
-std::list<Complex>
-gimmeComplexList()
+std::list<Complex> gimmeComplexList()
 {
     std::list<Complex> lst;
     lst.push_back(Complex());
@@ -41,39 +37,29 @@ gimmeComplexList()
     return lst;
 }
 
-Complex
-sumComplexPair(std::pair<Complex, Complex> cpx_pair)
+Complex sumComplexPair(std::pair<Complex, Complex> cpx_pair)
 {
     return cpx_pair.first + cpx_pair.second;
 }
 
-double
-multiplyPair(std::pair<double, double> pair)
+double multiplyPair(std::pair<double, double> pair)
 {
     return pair.first * pair.second;
 }
 
-int
-countCharacters(const char* text)
+int countCharacters(const char *text)
 {
-    if (!text)
-        return -1;
-    int count;
-    for(count = 0; text[count] != '\0'; count++)
-        ;
-    return count;
+    return text != nullptr ? int(std::strlen(text)) : -1;
 }
 
-char*
-makeCString()
+char *makeCString()
 {
-    char* string = new char[strlen(__FUNCTION__) + 1];
-    strcpy(string, __FUNCTION__);
+    char *string = new char[std::strlen(__FUNCTION__) + 1];
+    std::strcpy(string, __FUNCTION__);
     return string;
 }
 
-const char*
-returnCString()
+const char *returnCString()
 {
     return __FUNCTION__;
 }
@@ -88,86 +74,77 @@ GlobalOverloadFuncEnum overloadedFunc(double)
     return GlobalOverloadFunc_d;
 }
 
-char*
-returnNullPrimitivePointer()
+char *returnNullPrimitivePointer()
 {
     return nullptr;
 }
 
-ObjectType*
-returnNullObjectTypePointer()
+ObjectType *returnNullObjectTypePointer()
 {
     return nullptr;
 }
 
-Event*
-returnNullValueTypePointer()
+Event *returnNullValueTypePointer()
 {
     return nullptr;
 }
 
-unsigned int
-doubleUnsignedInt(unsigned int value)
+unsigned int doubleUnsignedInt(unsigned int value)
 {
     return value * 2;
 }
 
-long long
-doubleLongLong(long long value)
+long long doubleLongLong(long long value)
 {
     return value * 2;
 }
 
-unsigned long long
-doubleUnsignedLongLong(unsigned long long value)
+unsigned long long doubleUnsignedLongLong(unsigned long long value)
 {
     return value * 2;
 }
 
-short
-doubleShort(short value)
+short doubleShort(short value)
 {
     return value * 2;
 }
 
-int
-acceptInt(int x)
+int acceptInt(int x)
 {
     return x;
 }
 
-unsigned int
-acceptUInt(unsigned int x)
+const int *acceptIntReturnPtr(int x)
+{
+    return new int(x);
+}
+
+unsigned int acceptUInt(unsigned int x)
 {
     return x;
 }
 
-long
-acceptLong(long x)
+long acceptLong(long x)
 {
     return x;
 }
 
-unsigned long
-acceptULong(unsigned long x)
+unsigned long acceptULong(unsigned long x)
 {
     return x;
 }
 
-double
-acceptDouble(double x)
+double acceptDouble(double x)
 {
     return x;
 }
 
-int
-acceptIntReference(int& x)
+int acceptIntReference(int &x)
 {
     return x;
 }
 
-OddBool
-acceptOddBoolReference(OddBool& x)
+OddBool acceptOddBoolReference(OddBool &x)
 {
     return x;
 }
@@ -202,9 +179,7 @@ double sumDoubleMatrix(double m[2][3])
     return result;
 }
 
-ArrayModifyTest::ArrayModifyTest()
-{
-}
+ArrayModifyTest::ArrayModifyTest() = default;
 
 int ArrayModifyTest::sumIntArray(int n, int *array)
 {
@@ -227,7 +202,7 @@ void ClassWithFunctionPointer::doNothing(void *operand)
     (void) operand;
 }
 
-string addStdStrings(const std::string &s1, const std::string &s2)
+std::string addStdStrings(const std::string &s1, const std::string &s2)
 {
     return s1 + s2;
 }
@@ -239,5 +214,19 @@ std::wstring addStdWStrings(const std::wstring &s1, const std::wstring &s2)
 
 void testNullPtrT(std::nullptr_t)
 {
-    cout << __FUNCTION__ << '\n';
+    std::cout << __FUNCTION__ << '\n';
+}
+
+int takePolygon(Polygon &&p)
+{
+    auto p2 = std::move(p);
+    std::cout << __FUNCTION__ << ' ' << p2.points().size() << " points\n";
+    return int(p2.points().size());
+}
+
+int takeObjectType(ObjectType &&o)
+{
+    auto o2 = std::move(o);
+    std::cout << __FUNCTION__ << ' ' << o2.objectName().cstring()  << '\n';
+    return o2.objectName().size();
 }
diff --git a/sources/shiboken6/tests/libsample/functions.h b/sources/shiboken6/tests/libsample/functions.h
index 7492ec4c2..b745aed6b 100644
--- a/sources/shiboken6/tests/libsample/functions.h
+++ b/sources/shiboken6/tests/libsample/functions.h
@@ -5,12 +5,15 @@
 #define FUNCTIONS_H
 
 #include "libsamplemacros.h"
-#include <list>
-#include <utility>
 #include "oddbool.h"
 #include "complex.h"
 #include "objecttype.h"
 
+#include <list>
+#include <utility>
+
+class Polygon;
+
 enum GlobalEnum {
     NoThing,
     FirstThing,
@@ -30,13 +33,13 @@ LIBSAMPLE_API double multiplyPair(std::pair<double, double> pair);
 LIBSAMPLE_API std::list<Complex> gimmeComplexList();
 LIBSAMPLE_API Complex sumComplexPair(std::pair<Complex, Complex> cpx_pair);
 
-LIBSAMPLE_API int countCharacters(const char* text);
-LIBSAMPLE_API char* makeCString();
-LIBSAMPLE_API const char* returnCString();
+LIBSAMPLE_API int countCharacters(const char *text);
+LIBSAMPLE_API char *makeCString();
+LIBSAMPLE_API const char *returnCString();
 
-LIBSAMPLE_API char* returnNullPrimitivePointer();
-LIBSAMPLE_API ObjectType* returnNullObjectTypePointer();
-LIBSAMPLE_API Event* returnNullValueTypePointer();
+LIBSAMPLE_API char *returnNullPrimitivePointer();
+LIBSAMPLE_API ObjectType *returnNullObjectTypePointer();
+LIBSAMPLE_API Event *returnNullValueTypePointer();
 
 // Tests overloading on functions (!methods)
 LIBSAMPLE_API GlobalOverloadFuncEnum overloadedFunc(int val);
@@ -48,13 +51,14 @@ LIBSAMPLE_API unsigned long long doubleUnsignedLongLong(unsigned long long value
 LIBSAMPLE_API short doubleShort(short value);
 
 LIBSAMPLE_API int acceptInt(int x);
+LIBSAMPLE_API const int *acceptIntReturnPtr(int x);
 LIBSAMPLE_API unsigned int acceptUInt(unsigned int x);
 LIBSAMPLE_API long acceptLong(long x);
 LIBSAMPLE_API unsigned long acceptULong(unsigned long x);
 LIBSAMPLE_API double acceptDouble(double x);
 
-LIBSAMPLE_API int acceptIntReference(int& x);
-LIBSAMPLE_API OddBool acceptOddBoolReference(OddBool& x);
+LIBSAMPLE_API int acceptIntReference(int &x);
+LIBSAMPLE_API OddBool acceptOddBoolReference(OddBool &x);
 
 LIBSAMPLE_API int sumIntArray(int array[4]);
 LIBSAMPLE_API double sumDoubleArray(double array[4]);
@@ -66,6 +70,9 @@ LIBSAMPLE_API std::wstring addStdWStrings(const std::wstring &s1, const std::wst
 
 LIBSAMPLE_API void testNullPtrT(std::nullptr_t);
 
+LIBSAMPLE_API int takePolygon(Polygon &&p);
+LIBSAMPLE_API int takeObjectType(ObjectType &&o);
+
 class LIBSAMPLE_API ArrayModifyTest
 {
 public:
diff --git a/sources/shiboken6/tests/libsample/handle.cpp b/sources/shiboken6/tests/libsample/handle.cpp
index e92c24c89..93c2abe47 100644
--- a/sources/shiboken6/tests/libsample/handle.cpp
+++ b/sources/shiboken6/tests/libsample/handle.cpp
@@ -3,17 +3,17 @@
 
 #include "handle.h"
 
-HANDLE HandleHolder::createHandle()
+SAMPLE_HANDLE HandleHolder::createHandle()
 {
-    return (HANDLE) new OBJ;
+    return (SAMPLE_HANDLE) new OBJ;
 }
 
-bool HandleHolder::compare(HandleHolder* other)
+bool HandleHolder::compare(HandleHolder *other)
 {
     return other->m_handle == m_handle;
 }
 
-bool HandleHolder::compare2(HandleHolder* other)
+bool HandleHolder::compare2(HandleHolder *other)
 {
     return other->m_handle2 == m_handle2;
 }
diff --git a/sources/shiboken6/tests/libsample/handle.h b/sources/shiboken6/tests/libsample/handle.h
index 1ef80689d..07fc89d15 100644
--- a/sources/shiboken6/tests/libsample/handle.h
+++ b/sources/shiboken6/tests/libsample/handle.h
@@ -8,38 +8,38 @@
 
 /* See http://bugs.pyside.org/show_bug.cgi?id=1105. */
 namespace Foo {
-    using HANDLE = unsigned long;
+    using SAMPLE_HANDLE = unsigned long;
 }
 
 class LIBSAMPLE_API OBJ
 {
 };
 
-using HANDLE = OBJ *;
+using SAMPLE_HANDLE = OBJ *;
 
 class LIBSAMPLE_API HandleHolder
 {
 public:
-    explicit HandleHolder(HANDLE ptr = nullptr) : m_handle(ptr) {}
-    explicit HandleHolder(Foo::HANDLE val): m_handle2(val) {}
+    explicit HandleHolder(SAMPLE_HANDLE ptr = nullptr) : m_handle(ptr) {}
+    explicit HandleHolder(Foo::SAMPLE_HANDLE val): m_handle2(val) {}
 
-    void set(HANDLE ptr);
-    inline void set(const Foo::HANDLE& val) { m_handle2 = val; }
-    inline HANDLE handle() { return m_handle; }
-    inline Foo::HANDLE handle2() { return m_handle2; }
+    void set(SAMPLE_HANDLE ptr);
+    inline void set(const Foo::SAMPLE_HANDLE &val) { m_handle2 = val; }
+    inline SAMPLE_HANDLE handle() const { return m_handle; }
+    inline Foo::SAMPLE_HANDLE handle2() const { return m_handle2; }
 
-    static HANDLE createHandle();
-    bool compare(HandleHolder* other);
-    bool compare2(HandleHolder* other);
+    static SAMPLE_HANDLE createHandle();
+    bool compare(HandleHolder *other);
+    bool compare2(HandleHolder *other);
 
 private:
-    HANDLE m_handle;
-    Foo::HANDLE m_handle2;
+    SAMPLE_HANDLE m_handle = nullptr;
+    Foo::SAMPLE_HANDLE m_handle2 = 0;
 };
 
-inline void HandleHolder::set(HANDLE)
+inline void HandleHolder::set(SAMPLE_HANDLE)
 {
-    HANDLE tmp = m_handle;
+    SAMPLE_HANDLE tmp = m_handle;
     m_handle = tmp;
 }
 
diff --git a/sources/shiboken6/tests/libsample/implicitconv.cpp b/sources/shiboken6/tests/libsample/implicitconv.cpp
index fad17e879..887fa6b1c 100644
--- a/sources/shiboken6/tests/libsample/implicitconv.cpp
+++ b/sources/shiboken6/tests/libsample/implicitconv.cpp
@@ -8,40 +8,32 @@ ImplicitConv::ImplicitConv(const Null &) :
 {
 }
 
-ImplicitConv
-ImplicitConv::implicitConvCommon(ImplicitConv implicit)
+ImplicitConv ImplicitConv::implicitConvCommon(ImplicitConv implicit)
 {
     return implicit;
 }
 
-ImplicitConv
-ImplicitConv::implicitConvDefault(ImplicitConv implicit)
+ImplicitConv ImplicitConv::implicitConvDefault(ImplicitConv implicit)
 {
     return implicit;
 }
 
-ImplicitConv::ICOverloadedFuncEnum
-ImplicitConv::implicitConvOverloading(ImplicitConv, int)
+ImplicitConv::ICOverloadedFuncEnum ImplicitConv::implicitConvOverloading(ImplicitConv, int)
 {
     return ImplicitConv::OverFunc_Ii;
 }
 
-ImplicitConv::ICOverloadedFuncEnum
-ImplicitConv::implicitConvOverloading(ImplicitConv, bool)
+ImplicitConv::ICOverloadedFuncEnum ImplicitConv::implicitConvOverloading(ImplicitConv, bool)
 {
     return ImplicitConv::OverFunc_Ib;
 }
 
-ImplicitConv::ICOverloadedFuncEnum
-ImplicitConv::implicitConvOverloading(int)
+ImplicitConv::ICOverloadedFuncEnum ImplicitConv::implicitConvOverloading(int)
 {
     return ImplicitConv::OverFunc_i;
 }
 
-ImplicitConv::ICOverloadedFuncEnum
-ImplicitConv::implicitConvOverloading(CtorEnum)
+ImplicitConv::ICOverloadedFuncEnum ImplicitConv::implicitConvOverloading(CtorEnum)
 {
     return ImplicitConv::OverFunc_C;
 }
-
-
diff --git a/sources/shiboken6/tests/libsample/implicitconv.h b/sources/shiboken6/tests/libsample/implicitconv.h
index bd390b15c..5d69eb487 100644
--- a/sources/shiboken6/tests/libsample/implicitconv.h
+++ b/sources/shiboken6/tests/libsample/implicitconv.h
@@ -12,6 +12,8 @@ class ObjectType;
 class LIBSAMPLE_API ImplicitConv
 {
 public:
+    LIBMINIMAL_DEFAULT_COPY_MOVE(ImplicitConv)
+
     enum CtorEnum {
         CtorNone,
         CtorOne,
@@ -28,17 +30,17 @@ public:
         OverFunc_C
     };
 
-    ImplicitConv() : m_ctorEnum(CtorNone), m_objId(-1), m_value(-1.0) {}
-    ImplicitConv(int objId) : m_ctorEnum(CtorOne), m_objId(objId), m_value(-1.0) {}
-    ImplicitConv(CtorEnum ctorEnum) : m_ctorEnum(ctorEnum), m_objId(-1), m_value(-1.0) {}
-    ImplicitConv(ObjectType&) : m_ctorEnum(CtorObjectTypeReference), m_objId(-1), m_value(-1.0) {}
+    ImplicitConv() noexcept = default;
+    ImplicitConv(int objId) noexcept : m_ctorEnum(CtorOne), m_objId(objId) {}
+    ImplicitConv(CtorEnum ctorEnum) : m_ctorEnum(ctorEnum) {}
+    ImplicitConv(ObjectType&) : m_ctorEnum(CtorObjectTypeReference) {}
     ImplicitConv(double value, bool=true) : m_ctorEnum(CtorNone), m_value(value) {}
     ImplicitConv(const Null &null);
-    ~ImplicitConv() {}
+    ~ImplicitConv() = default;
 
-    inline CtorEnum ctorEnum() { return m_ctorEnum; }
-    inline int objId() { return m_objId; }
-    inline double value() { return m_value; }
+    inline CtorEnum ctorEnum() const { return m_ctorEnum; }
+    inline int objId() const { return m_objId; }
+    inline double value() const { return m_value; }
 
     static ImplicitConv implicitConvCommon(ImplicitConv implicit);
 
@@ -50,9 +52,9 @@ public:
     static ICOverloadedFuncEnum implicitConvOverloading(CtorEnum dummyArg);
 
 private:
-    CtorEnum m_ctorEnum;
-    int m_objId;
-    double m_value;
+    CtorEnum m_ctorEnum = CtorNone;
+    int m_objId = -1;
+    double m_value = -1.0;
 };
 
 #endif // IMPLICITCONV_H
diff --git a/sources/shiboken6/tests/libsample/injectcode.cpp b/sources/shiboken6/tests/libsample/injectcode.cpp
index 488f7faae..707d14ed8 100644
--- a/sources/shiboken6/tests/libsample/injectcode.cpp
+++ b/sources/shiboken6/tests/libsample/injectcode.cpp
@@ -2,20 +2,15 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "injectcode.h"
-#include <sstream>
 
-using namespace std;
+#include <sstream>
 
-InjectCode::InjectCode()
-{
-}
+InjectCode::InjectCode() noexcept = default;
 
-InjectCode::~InjectCode()
-{
-}
+InjectCode::~InjectCode() = default;
 
 template<typename T>
-const char* InjectCode::toStr(const T& value)
+const char *InjectCode::toStr(const T &value)
 {
     std::ostringstream s;
     s << value;
@@ -23,41 +18,41 @@ const char* InjectCode::toStr(const T& value)
     return m_valueHolder.c_str();
 }
 
-const char* InjectCode::simpleMethod1(int arg0, int arg1)
+const char *InjectCode::simpleMethod1(int arg0, int arg1)
 {
     return toStr(arg0 + arg1);
 }
 
-const char* InjectCode::simpleMethod2()
+const char *InjectCode::simpleMethod2()
 {
     return "_";
 }
 
-const char* InjectCode::simpleMethod3(int argc, char** argv)
+const char *InjectCode::simpleMethod3(int argc, char **argv)
 {
     for (int i = 0; i < argc; ++i)
         m_valueHolder += argv[i];
     return m_valueHolder.c_str();
 }
 
-const char* InjectCode::overloadedMethod(int arg0, bool arg1)
+const char *InjectCode::overloadedMethod(int arg0, bool arg1)
 {
     toStr(arg0);
     m_valueHolder += arg1 ? "true" : "false";
     return m_valueHolder.c_str();
 }
 
-const char* InjectCode::overloadedMethod(int arg0, double arg1)
+const char *InjectCode::overloadedMethod(int arg0, double arg1)
 {
     return toStr(arg0 + arg1);
 }
 
-const char* InjectCode::overloadedMethod(int argc, char** argv)
+const char *InjectCode::overloadedMethod(int argc, char **argv)
 {
     return simpleMethod3(argc, argv);
 }
 
-const char* InjectCode::virtualMethod(int arg)
+const char *InjectCode::virtualMethod(int arg)
 {
     return toStr(arg);
 }
@@ -70,13 +65,13 @@ int InjectCode::arrayMethod(int count, int *values) const
     return ret;
 }
 
-int InjectCode::sumArrayAndLength(int* values) const
+int InjectCode::sumArrayAndLength(int *values) const
 {
     int sum = 0;
 
-    while(*values) {
+    while (*values) {
         sum = sum + *values + 1;
-        values++;
+        ++values;
     }
 
     return sum;
diff --git a/sources/shiboken6/tests/libsample/injectcode.h b/sources/shiboken6/tests/libsample/injectcode.h
index 43a3e8468..74046dad5 100644
--- a/sources/shiboken6/tests/libsample/injectcode.h
+++ b/sources/shiboken6/tests/libsample/injectcode.h
@@ -5,27 +5,31 @@
 #define INJECTCODE_H
 
 #include "libsamplemacros.h"
+
 #include <utility>
 #include <string>
 
 class LIBSAMPLE_API InjectCode
 {
 public:
-    InjectCode();
+    LIBMINIMAL_DEFAULT_COPY_MOVE(InjectCode)
+
+    InjectCode() noexcept;
     virtual ~InjectCode();
 
-    const char* simpleMethod1(int arg0, int arg1);
-    const char* simpleMethod2();
-    const char* simpleMethod3(int argc, char** argv);
+    const char *simpleMethod1(int arg0, int arg1);
+    const char *simpleMethod2();
+    const char *simpleMethod3(int argc, char **argv);
 
-    const char* overloadedMethod(int argc, char** argv);
-    const char* overloadedMethod(int arg0, double arg1);
-    const char* overloadedMethod(int arg0, bool arg1);
+   const char *overloadedMethod(int argc, char **argv);
+    const char *overloadedMethod(int arg0, double arg1);
+    const char *overloadedMethod(int arg0, bool arg1);
 
-    virtual int arrayMethod(int count, int* values) const;
+    virtual int arrayMethod(int count, int *values) const;
     inline int callArrayMethod(int count, int *values) const { return arrayMethod(count, values); }
-    virtual const char* virtualMethod(int arg);
-    int sumArrayAndLength(int* values) const;
+    virtual const char *virtualMethod(int arg);
+    int sumArrayAndLength(int *values) const;
+
 private:
     // This attr is just to retain the memory pointed by all return values,
     // So, the memory returned by all methods will be valid until someone call
@@ -33,7 +37,7 @@ private:
     std::string m_valueHolder;
 
     template<typename T>
-    const char* toStr(const T& value);
+    const char *toStr(const T &value);
 };
 
 #endif // INJECTCODE_H
diff --git a/sources/shiboken6/tests/libsample/list.h b/sources/shiboken6/tests/libsample/list.h
index 5b0eabb02..5e06d2a66 100644
--- a/sources/shiboken6/tests/libsample/list.h
+++ b/sources/shiboken6/tests/libsample/list.h
@@ -18,6 +18,8 @@ class List : public std::list<T>
 class IntList : public List<int>
 {
 public:
+    LIBMINIMAL_DEFAULT_MOVE(IntList)
+
     enum CtorEnum {
         NoParamsCtor,
         IntCtor,
@@ -25,14 +27,13 @@ public:
         ListOfIntCtor
     };
 
-    inline IntList() : m_ctorUsed(NoParamsCtor) {}
+    inline IntList() noexcept : m_ctorUsed(NoParamsCtor) {}
     inline explicit IntList(int val) : m_ctorUsed(IntCtor) { push_back(val); }
-    inline IntList(const List<int>& lst) : List<int>(lst), m_ctorUsed(ListOfIntCtor) {}
+    inline IntList(const List<int> &lst) : List<int>(lst), m_ctorUsed(ListOfIntCtor) {}
+    ~IntList() = default;
 
-    inline IntList(const IntList& lst) : List<int>(lst), m_ctorUsed(CopyCtor) {}
-    IntList(IntList &&) = default;
+    inline IntList(const IntList &lst) : List<int>(lst), m_ctorUsed(CopyCtor) {}
     IntList &operator=(const IntList &) = default;
-    IntList &operator=(IntList &&) = default;
 
     inline void append(int v) { insert(end(), v); }
     CtorEnum constructorUsed() { return m_ctorUsed; }
@@ -43,6 +44,8 @@ private:
 class PointValueList : public List<Point>
 {
 public:
+    LIBMINIMAL_DEFAULT_MOVE(PointValueList)
+
     enum CtorEnum {
         NoParamsCtor,
         PointCtor,
@@ -50,14 +53,13 @@ public:
         ListOfPointValuesCtor
     };
 
-    inline PointValueList() : m_ctorUsed(NoParamsCtor) {}
+    inline PointValueList() noexcept : m_ctorUsed(NoParamsCtor) {}
     inline explicit PointValueList(Point val) : m_ctorUsed(PointCtor) { push_back(val); }
-    inline PointValueList(const List<Point>& lst) : List<Point>(lst), m_ctorUsed(ListOfPointValuesCtor) {}
+    inline PointValueList(const List<Point> &lst) : List<Point>(lst), m_ctorUsed(ListOfPointValuesCtor) {}
 
-    inline PointValueList(const PointValueList& lst) : List<Point>(lst), m_ctorUsed(CopyCtor) {}
-    PointValueList(PointValueList &&) = default;
+    inline PointValueList(const PointValueList &lst) : List<Point>(lst), m_ctorUsed(CopyCtor) {}
     PointValueList &operator=(const PointValueList &) = default;
-    PointValueList &operator=(PointValueList &&) = default;
+    ~PointValueList() = default;
 
     inline void append(Point v) { insert(end(), v); }
     CtorEnum constructorUsed() { return m_ctorUsed; }
@@ -68,6 +70,8 @@ private:
 class ObjectTypePtrList : public List<ObjectType*>
 {
 public:
+    LIBMINIMAL_DEFAULT_MOVE(ObjectTypePtrList)
+
     enum CtorEnum {
         NoParamsCtor,
         ObjectTypeCtor,
@@ -75,19 +79,21 @@ public:
         ListOfObjectTypePtrCtor
     };
 
-    inline ObjectTypePtrList() : m_ctorUsed(NoParamsCtor) {}
-    inline explicit ObjectTypePtrList(ObjectType* val) : m_ctorUsed(ObjectTypeCtor) { push_back(val); }
-    inline ObjectTypePtrList(const List<ObjectType*>& lst) : List<ObjectType*>(lst), m_ctorUsed(ListOfObjectTypePtrCtor) {}
+    inline ObjectTypePtrList() = default;
+    inline ObjectTypePtrList(const ObjectTypePtrList &lst) :
+        List<ObjectType*>(lst), m_ctorUsed(CopyCtor) {}
+    inline explicit ObjectTypePtrList(ObjectType *val) :
+        m_ctorUsed(ObjectTypeCtor) { push_back(val); }
+    inline ObjectTypePtrList(const List<ObjectType*> &lst) :
+        List<ObjectType*>(lst), m_ctorUsed(ListOfObjectTypePtrCtor) {}
+    ~ObjectTypePtrList() = default;
 
-    inline ObjectTypePtrList(const ObjectTypePtrList& lst) : List<ObjectType*>(lst), m_ctorUsed(CopyCtor) {}
-    ObjectTypePtrList(ObjectTypePtrList &&) = default;
     ObjectTypePtrList &operator=(const ObjectTypePtrList &) = default;
-    ObjectTypePtrList &operator=(ObjectTypePtrList &&) = default;
 
-    inline void append(ObjectType* v) { insert(end(), v); }
+    inline void append(ObjectType *v) { insert(end(), v); }
     CtorEnum constructorUsed() { return m_ctorUsed; }
 private:
-    CtorEnum m_ctorUsed;
+    CtorEnum m_ctorUsed = NoParamsCtor;
 };
 
 #endif // LIST_H
diff --git a/sources/shiboken6/tests/libsample/listuser.cpp b/sources/shiboken6/tests/libsample/listuser.cpp
index 6801bfdf3..9bb7f7798 100644
--- a/sources/shiboken6/tests/libsample/listuser.cpp
+++ b/sources/shiboken6/tests/libsample/listuser.cpp
@@ -1,27 +1,24 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <numeric>
-#include <cstdlib>
 #include "listuser.h"
 
-using namespace std;
+#include <numeric>
+#include <cstdlib>
 
-std::list<int>
-ListUser::callCreateList()
+std::list<int> ListUser::callCreateList()
 {
     return createList();
 }
 
 ListUser::ListUser() = default;
 ListUser::ListUser(const ListUser &other) = default;
-ListUser::ListUser(ListUser &&other) = default;
+ListUser::ListUser(ListUser &&other) noexcept = default;
 ListUser &ListUser::operator=(const ListUser &other) = default;
-ListUser &ListUser::operator=(ListUser &&other) = default;
+ListUser &ListUser::operator=(ListUser &&other) noexcept = default;
 ListUser::~ListUser() = default;
 
-std::list<int>
-ListUser::createList()
+std::list<int> ListUser::createList()
 {
     std::list<int> retval;
     for (int i = 0; i < 4; i++)
@@ -29,8 +26,7 @@ ListUser::createList()
     return retval;
 }
 
-std::list<Complex>
-ListUser::createComplexList(Complex cpx0, Complex cpx1)
+std::list<Complex> ListUser::createComplexList(Complex cpx0, Complex cpx1)
 {
     std::list<Complex> retval;
     retval.push_back(cpx0);
@@ -38,14 +34,12 @@ ListUser::createComplexList(Complex cpx0, Complex cpx1)
     return retval;
 }
 
-double
-ListUser::sumList(std::list<int> vallist)
+double ListUser::sumList(std::list<int> vallist)
 {
     return std::accumulate(vallist.begin(), vallist.end(), 0.0);
 }
 
-double
-ListUser::sumList(std::list<double> vallist)
+double ListUser::sumList(std::list<double> vallist)
 {
     return std::accumulate(vallist.begin(), vallist.end(), 0.0);
 }
@@ -60,12 +54,10 @@ ListUser::ListOfSomething ListUser::listOfPoints(const std::list<PointF> &)
     return ListOfPointF;
 }
 
-void
-ListUser::multiplyPointList(PointList& points, double multiplier)
+void ListUser::multiplyPointList(PointList &points, double multiplier)
 {
     for (auto *point : points) {
         point->setX(point->x() * multiplier);
         point->setY(point->y() * multiplier);
     }
 }
-
diff --git a/sources/shiboken6/tests/libsample/listuser.h b/sources/shiboken6/tests/libsample/listuser.h
index 9351ffb7a..96781ed16 100644
--- a/sources/shiboken6/tests/libsample/listuser.h
+++ b/sources/shiboken6/tests/libsample/listuser.h
@@ -4,13 +4,14 @@
 #ifndef LISTUSER_H
 #define LISTUSER_H
 
-#include <list>
 #include "complex.h"
 #include "point.h"
 #include "pointf.h"
 
 #include "libsamplemacros.h"
 
+#include <list>
+
 class LIBSAMPLE_API ListUser
 {
 public:
@@ -23,9 +24,9 @@ public:
 
     ListUser();
     ListUser(const ListUser &other);
-    ListUser(ListUser &&other);
+    ListUser(ListUser &&other) noexcept;
     ListUser &operator=(const ListUser &other);
-    ListUser &operator=(ListUser &&other);
+    ListUser &operator=(ListUser &&other) noexcept;
     virtual ~ListUser();
 
     virtual std::list<int> createList();
@@ -36,13 +37,13 @@ public:
     double sumList(std::list<int> vallist);
     double sumList(std::list<double> vallist);
 
-    static ListOfSomething listOfPoints(const std::list<Point>& pointlist);
-    static ListOfSomething listOfPoints(const std::list<PointF>& pointlist);
+    static ListOfSomething listOfPoints(const std::list<Point> &pointlist);
+    static ListOfSomething listOfPoints(const std::list<PointF> &pointlist);
 
-    static void multiplyPointList(PointList& points, double multiplier);
+    static void multiplyPointList(PointList &points, double multiplier);
 
     inline void setList(std::list<int> lst) { m_lst = lst; }
-    inline std::list<int> getList() { return m_lst; }
+    inline std::list<int> getList() const { return m_lst; }
 
 private:
     std::list<int> m_lst;
diff --git a/sources/shiboken6/tests/libsample/main.cpp b/sources/shiboken6/tests/libsample/main.cpp
index 9d62e753b..1b44642ae 100644
--- a/sources/shiboken6/tests/libsample/main.cpp
+++ b/sources/shiboken6/tests/libsample/main.cpp
@@ -12,207 +12,197 @@
 #include "listuser.h"
 #include "samplenamespace.h"
 
-using namespace std;
-
 int
 main(int argv, char **argc)
 {
-    cout << endl;
+    std::cout << std::endl;
 
     Derived derived;
 
-    cout << endl;
+    std::cout << std::endl;
 
     derived.unpureVirtual();
     derived.pureVirtual();
     derived.callPureVirtual();
 
-    cout << endl;
-    Abstract* abs;
-    abs = Abstract::createObject();
-    cout << "Abstract::createObject(): " << abs << endl << endl;
+    std::cout << std::endl;
+    auto *abs = Abstract::createObject();
+    std::cout << "Abstract::createObject(): " << abs << std::endl << std::endl;
     delete abs;
 
     abs = Derived::createObject();
-    cout << "Derived::createObject() : ";
+    std::cout << "Derived::createObject() : ";
     abs->show();
-    cout << endl;
+    std::cout << std::endl;
     delete abs;
-    cout << endl;
+    std::cout << std::endl;
 
     abs = Derived::createObject();
-    cout << "Derived::createObject() : ";
+    std::cout << "Derived::createObject() : ";
     abs->show();
-    cout << endl;
+    std::cout << std::endl;
     delete abs;
-    cout << endl;
+    std::cout << std::endl;
 
-    cout << endl << "-----------------------------------------" << endl;
+    std::cout << "\n-----------------------------------------\n";
 
     KinderGarten kg;
-    Derived* d[] = { 0, 0, 0 };
+    Derived *d[] = { 0, 0, 0 };
 
     for (int i = 0; i < 3; i++) {
         d[i] = new Derived(i);
         d[i]->show();
-        cout << endl;
+        std::cout << std::endl;
         kg.addChild(d[i]);
     }
 
     kg.show();
-    cout << endl;
+    std::cout << std::endl;
 
-    cout << endl << "* kill child ";
+    std::cout << "\n* kill child ";
     d[2]->show();
-    cout << " ----------------" << endl;
+    std::cout << " ----------------\n";
     kg.killChild(d[2]);
     kg.show();
-    cout << endl;
+    std::cout << std::endl;
 
-    cout << endl << "* release child ";
+    std::cout << "\n* release child ";
     d[1]->show();
-    cout << " -------------" << endl;
-    Abstract* released = kg.releaseChild(d[1]);
-    cout << "released: ";
+    std::cout << " -------------\n";
+    Abstract *released = kg.releaseChild(d[1]);
+    std::cout << "released: ";
     released->show();
-    cout << endl;
+    std::cout << std::endl;
     kg.show();
-    cout << endl;
-
-    cout << endl << "* kill children ------------------------------------" << endl;
+    std::cout << "\n\n* kill children ------------------------------------\n";
     kg.killChildren();
     kg.show();
-    cout << endl << endl;
-
-    cout << "-----------------------------------------" << endl;
+    std::cout << "\n\n-----------------------------------------\n";
     ListUser lu;
-    cout << "ListUser::createList()" << endl;
+    std::cout << "ListUser::createList()\n";
     std::list<int> intlist = lu.createList();
-    for (std::list<int>::iterator it = intlist.begin(); it != intlist.end(); it++) {
-        cout << "* " << *it << endl;
-    }
+    for (std::list<int>::iterator it = intlist.begin(); it != intlist.end(); it++)
+        std::cout << "* " << *it << std::endl;
 
-    cout << "ListUser::createComplexList" << endl;
+    std::cout << "ListUser::createComplexList\n";
     std::list<Complex> cpxlist = ListUser::createComplexList(Complex(1.1, 2.2), Complex(3.3, 4.4));
     for (std::list<Complex>::iterator it = cpxlist.begin(); it != cpxlist.end(); it++) {
-        cout << "* ";
+        std::cout << "* ";
         (*it).show();
-        cout << endl;
+        std::cout << std::endl;
     }
-    cout << endl;
-
-    cout << "-----------------------------------------" << endl;
-    cout << "SampleNamespace" << endl;
-
-    cout << "SampleNamespace::RandomNumber: ";
-    cout << SampleNamespace::getNumber(SampleNamespace::RandomNumber);
-    cout << endl;
-    cout << "SampleNamespace::UnixTime: ";
-    cout << SampleNamespace::getNumber(SampleNamespace::UnixTime);
-    cout << endl;
+    std::cout << "\n-----------------------------------------\n"
+        << "SampleNamespace\n";
+
+    std::cout << "SampleNamespace::RandomNumber: ";
+    std::cout << SampleNamespace::getNumber(SampleNamespace::RandomNumber);
+    std::cout << std::endl;
+    std::cout << "SampleNamespace::UnixTime: ";
+    std::cout << SampleNamespace::getNumber(SampleNamespace::UnixTime);
+    std::cout << std::endl;
     double val_d = 1.3;
-    cout << "SampleNamespace::powerOfTwo(" << val_d << "): ";
-    cout << SampleNamespace::powerOfTwo(val_d) << endl;
+    std::cout << "SampleNamespace::powerOfTwo(" << val_d << "): ";
+    std::cout << SampleNamespace::powerOfTwo(val_d) << std::endl;
     int val_i = 7;
-    cout << "SampleNamespace::powerOfTwo(" << val_i << "): ";
-    cout << SampleNamespace::powerOfTwo(val_i) << endl;
-    cout << endl;
+    std::cout << "SampleNamespace::powerOfTwo(" << val_i << "): ";
+    std::cout << SampleNamespace::powerOfTwo(val_i) << std::endl;
+    std::cout << std::endl;
 
-    cout << "-----------------------------------------" << endl;
-    cout << "Point" << endl;
+    std::cout << "-----------------------------------------" << std::endl;
+    std::cout << "Point" << std::endl;
 
     Point p1(1.1, 2.2);
-    cout << "p1: ";
+    std::cout << "p1: ";
     p1.show();
-    cout << endl;
+    std::cout << std::endl;
 
     Point p2(3.4, 5.6);
-    cout << "p2: ";
+    std::cout << "p2: ";
     p2.show();
-    cout << endl;
+    std::cout << std::endl;
 
-    cout << "p1 + p2 == ";
+    std::cout << "p1 + p2 == ";
     (p1 + p2).show();
-    cout << endl;
+    std::cout << std::endl;
 
-    cout << "p1 * 2.0 == ";
+    std::cout << "p1 * 2.0 == ";
     (p1 * 2.0).show();
-    cout << endl;
+    std::cout << std::endl;
 
-    cout << "1.5 * p2 == ";
+    std::cout << "1.5 * p2 == ";
     (1.5 * p2).show();
-    cout << endl;
+    std::cout << std::endl;
 
-    cout << "p1: ";
+    std::cout << "p1: ";
     p1.show();
-    cout << endl << "p2: ";
+    std::cout << std::endl << "p2: ";
     p2.show();
-    cout << endl << "p1 += p2" << endl;
+    std::cout << std::endl << "p1 += p2" << std::endl;
     p1 += p2;
-    cout << "p1: ";
+    std::cout << "p1: ";
     p1.show();
-    cout << endl;
+    std::cout << std::endl;
 
-    cout << "p1 == p2 ? " << ((p1 == p2) ? "true" : "false") << endl;
-    cout << "p1 == p1 ? " << ((p1 == p1) ? "true" : "false") << endl;
-    cout << "p2 == p2 ? " << ((p2 == p2) ? "true" : "false") << endl;
+    std::cout << "p1 == p2 ? " << ((p1 == p2) ? "true" : "false") << std::endl;
+    std::cout << "p1 == p1 ? " << ((p1 == p1) ? "true" : "false") << std::endl;
+    std::cout << "p2 == p2 ? " << ((p2 == p2) ? "true" : "false") << std::endl;
 
-    cout << "-----------------------------------------" << endl;
-    cout << "Size" << endl;
+    std::cout << "-----------------------------------------" << std::endl;
+    std::cout << "Size" << std::endl;
 
     Size s1(2, 2);
-    cout << "s1: ";
+    std::cout << "s1: ";
     s1.show();
-    cout << ", area: " << s1.calculateArea();
-    cout << endl;
+    std::cout << ", area: " << s1.calculateArea();
+    std::cout << std::endl;
 
     Size s2(3, 5);
-    cout << "s2: ";
+    std::cout << "s2: ";
     s2.show();
-    cout << ", area: " << s2.calculateArea();
-    cout << endl;
-
-    cout << endl;
-
-    cout << "s1 == s2 ? " << ((s1 == s2) ? "true" : "false") << endl;
-    cout << "s1 != s2 ? " << ((s1 != s2) ? "true" : "false") << endl;
-
-    cout << "s1 <  s2 ? " << ((s1 <  s2) ? "true" : "false") << endl;
-    cout << "s1 <= s2 ? " << ((s1 <= s2) ? "true" : "false") << endl;
-    cout << "s1 >  s2 ? " << ((s1 >  s2) ? "true" : "false") << endl;
-    cout << "s1 >= s2 ? " << ((s1 >= s2) ? "true" : "false") << endl;
-
-    cout << "s1 <  10 ? " << ((s1 <  10) ? "true" : "false") << endl;
-    cout << "s1 <= 10 ? " << ((s1 <= 10) ? "true" : "false") << endl;
-    cout << "s1 >  10 ? " << ((s1 >  10) ? "true" : "false") << endl;
-    cout << "s1 >= 10 ? " << ((s1 >= 10) ? "true" : "false") << endl;
-    cout << "s2 <  10 ? " << ((s2 <  10) ? "true" : "false") << endl;
-    cout << "s2 <= 10 ? " << ((s2 <= 10) ? "true" : "false") << endl;
-    cout << "s2 >  10 ? " << ((s2 >  10) ? "true" : "false") << endl;
-    cout << "s2 >= 10 ? " << ((s2 >= 10) ? "true" : "false") << endl;
-    cout << endl;
-
-    cout << "s1: ";
+    std::cout << ", area: " << s2.calculateArea();
+    std::cout << std::endl;
+
+    std::cout << std::endl;
+
+    std::cout << "s1 == s2 ? " << ((s1 == s2) ? "true" : "false") << std::endl;
+    std::cout << "s1 != s2 ? " << ((s1 != s2) ? "true" : "false") << std::endl;
+
+    std::cout << "s1 <  s2 ? " << ((s1 <  s2) ? "true" : "false") << std::endl;
+    std::cout << "s1 <= s2 ? " << ((s1 <= s2) ? "true" : "false") << std::endl;
+    std::cout << "s1 >  s2 ? " << ((s1 >  s2) ? "true" : "false") << std::endl;
+    std::cout << "s1 >= s2 ? " << ((s1 >= s2) ? "true" : "false") << std::endl;
+
+    std::cout << "s1 <  10 ? " << ((s1 <  10) ? "true" : "false") << std::endl;
+    std::cout << "s1 <= 10 ? " << ((s1 <= 10) ? "true" : "false") << std::endl;
+    std::cout << "s1 >  10 ? " << ((s1 >  10) ? "true" : "false") << std::endl;
+    std::cout << "s1 >= 10 ? " << ((s1 >= 10) ? "true" : "false") << std::endl;
+    std::cout << "s2 <  10 ? " << ((s2 <  10) ? "true" : "false") << std::endl;
+    std::cout << "s2 <= 10 ? " << ((s2 <= 10) ? "true" : "false") << std::endl;
+    std::cout << "s2 >  10 ? " << ((s2 >  10) ? "true" : "false") << std::endl;
+    std::cout << "s2 >= 10 ? " << ((s2 >= 10) ? "true" : "false") << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "s1: ";
     s1.show();
-    cout << endl << "s2: ";
+    std::cout << std::endl << "s2: ";
     s2.show();
-    cout << endl << "s1 += s2" << endl;
+    std::cout << std::endl << "s1 += s2" << std::endl;
     s1 += s2;
-    cout << "s1: ";
+    std::cout << "s1: ";
     s1.show();
-    cout << endl;
+    std::cout << std::endl;
 
-    cout << endl;
+    std::cout << std::endl;
 
-    cout << "s1: ";
+    std::cout << "s1: ";
     s1.show();
-    cout << endl << "s1 *= 2.0" << endl;
+    std::cout << std::endl << "s1 *= 2.0" << std::endl;
     s1 *= 2.0;
-    cout << "s1: ";
+    std::cout << "s1: ";
     s1.show();
-    cout << endl;
+    std::cout << std::endl;
 
-    cout << endl;
+    std::cout << std::endl;
 
     return 0;
 }
diff --git a/sources/shiboken6/tests/libsample/mapuser.cpp b/sources/shiboken6/tests/libsample/mapuser.cpp
index 032d465d8..40059bbcd 100644
--- a/sources/shiboken6/tests/libsample/mapuser.cpp
+++ b/sources/shiboken6/tests/libsample/mapuser.cpp
@@ -1,44 +1,36 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
 #include "mapuser.h"
 
-using namespace std;
+#include <iostream>
 
-std::map<std::string, std::pair<Complex, int> >
-MapUser::callCreateMap()
+std::map<std::string, std::pair<Complex, int> > MapUser::callCreateMap()
 {
     return createMap();
 }
 
-
-std::map<std::string, std::pair<Complex, int> >
-MapUser::createMap()
+std::map<std::string, std::pair<Complex, int> > MapUser::createMap()
 {
     std::map<std::string, std::pair<Complex, int> > retval;
 
-    std::pair<std::string, std::pair<Complex, int> >
-            item0("zero", std::pair<Complex, int>(Complex(1.2, 3.4), 2));
-    retval.insert(item0);
+    std::pair<Complex, int> value{Complex(1.2, 3.4), 2};
+    retval.insert({"zero", value});
 
-    std::pair<std::string, std::pair<Complex, int> >
-            item1("one", std::pair<Complex, int>(Complex(5.6, 7.8), 3));
-    retval.insert(item1);
+    value = {Complex(5.6, 7.8), 3};
+    retval.insert({"one", value});
 
-    std::pair<std::string, std::pair<Complex, int> >
-            item2("two", std::pair<Complex, int>(Complex(9.1, 2.3), 5));
-    retval.insert(item2);
+    value = {Complex(9.1, 2.3), 5};
+    retval.insert({"two", value});
 
     return retval;
 }
 
-void
-MapUser::showMap(std::map<std::string, int> mapping)
+void MapUser::showMap(std::map<std::string, int> mapping)
 {
-    cout << __FUNCTION__ << endl;
-    for (auto it = mapping.begin(), end = mapping.end(); it != end; ++it)
-        cout << (*it).first << " => " << (*it).second << endl;
+    std::cout << __FUNCTION__ << std::endl;
+    for (const auto &p : mapping)
+        std::cout << p.first << " => " << p.second << std::endl;
 }
 
 void MapUser::pointerToMap(std::map<std::string, std::string> *)
diff --git a/sources/shiboken6/tests/libsample/mapuser.h b/sources/shiboken6/tests/libsample/mapuser.h
index 49318743c..1677a4bfb 100644
--- a/sources/shiboken6/tests/libsample/mapuser.h
+++ b/sources/shiboken6/tests/libsample/mapuser.h
@@ -4,20 +4,23 @@
 #ifndef MAPUSER_H
 #define MAPUSER_H
 
+#include "libsamplemacros.h"
+
+#include "complex.h"
+#include "bytearray.h"
+
 #include <map>
 #include <list>
 #include <utility>
 #include <string>
-#include "complex.h"
-#include "bytearray.h"
-
-#include "libsamplemacros.h"
 
 class LIBSAMPLE_API MapUser
 {
 public:
-    MapUser() {}
-    virtual ~MapUser() {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(MapUser)
+
+    MapUser() noexcept = default;
+    virtual ~MapUser() = default;
 
     virtual std::map<std::string, std::pair<Complex, int> > createMap();
     std::map<std::string, std::pair<Complex, int> > callCreateMap();
@@ -31,7 +34,7 @@ public:
     static void pointerToMap(std::map<std::string, std::string> *arg);
     static void referenceToMap(std::map<std::string, std::string> &arg);
 
-    inline const std::map<int, ByteArray>& passMapIntValueType(const std::map<int, ByteArray>& arg) { return arg; }
+    inline const std::map<int, ByteArray> &passMapIntValueType(const std::map<int, ByteArray>& arg) { return arg; }
 
     std::map<int, std::list<std::list<double> > > foo() const;
 
diff --git a/sources/shiboken6/tests/libsample/modelindex.h b/sources/shiboken6/tests/libsample/modelindex.h
index 6ed192329..48e1b7de3 100644
--- a/sources/shiboken6/tests/libsample/modelindex.h
+++ b/sources/shiboken6/tests/libsample/modelindex.h
@@ -4,8 +4,6 @@
 #ifndef MODELINDEX_H
 #define MODELINDEX_H
 
-#include "libsamplemacros.h"
-
 class ModelIndex
 {
 public:
@@ -13,7 +11,8 @@ public:
 
     inline void setValue(int value) { m_value = value; }
     inline int value() const { return m_value; }
-    static int getValue(const ModelIndex& index) { return index.value(); }
+    static int getValue(const ModelIndex &index) { return index.value(); }
+
 private:
     int m_value = 0;
 };
@@ -23,11 +22,12 @@ class ReferentModelIndex
 public:
     ReferentModelIndex() = default;
 
-    explicit ReferentModelIndex(const ModelIndex& index) : m_index(index) {}
+    explicit ReferentModelIndex(const ModelIndex &index) : m_index(index) {}
 
     inline void setValue(int value) { m_index.setValue(value); }
     inline int value() const { return m_index.value(); }
     operator const ModelIndex&() const { return m_index; }
+
 private:
     ModelIndex m_index;
 };
@@ -37,13 +37,14 @@ class PersistentModelIndex
 public:
     PersistentModelIndex() = default;
 
-    explicit PersistentModelIndex(const ModelIndex& index) : m_index(index) {}
+    explicit PersistentModelIndex(const ModelIndex &index) : m_index(index) {}
 
     inline void setValue(int value) { m_index.setValue(value); }
     inline int value() const { return m_index.value(); }
     operator ModelIndex() const { return m_index; }
+
 private:
     ModelIndex m_index;
 };
 
-#endif
+#endif // MODELINDEX_H
diff --git a/sources/shiboken6/tests/libsample/modifications.cpp b/sources/shiboken6/tests/libsample/modifications.cpp
index 8b1ba07dc..6d627c4c1 100644
--- a/sources/shiboken6/tests/libsample/modifications.cpp
+++ b/sources/shiboken6/tests/libsample/modifications.cpp
@@ -1,15 +1,14 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
 #include "modifications.h"
 #include "objecttype.h"
 
-using namespace std;
+#include <iostream>
 
 Modifications::Modifications()
+    : m_object(new ObjectType())
 {
-    m_object = new ObjectType();
     m_object->setObjectName("MyObject");
 }
 
@@ -79,30 +78,26 @@ void Modifications::argRemoval5(int, bool, int, bool)
 {
 }
 
-std::pair<double, double>
-Modifications::pointToPair(Point pt, bool* ok)
+std::pair<double, double> Modifications::pointToPair(Point pt, bool *ok)
 {
     std::pair<double, double> retval(pt.x(), pt.y());
     *ok = true;
     return retval;
 }
 
-double
-Modifications::multiplyPointCoordsPlusValue(bool* ok, Point pt, double value)
+double Modifications::multiplyPointCoordsPlusValue(bool *ok, Point pt, double value)
 {
     double retval = (pt.x() * pt.y()) + value;
     *ok = true;
     return retval;
 }
 
-int
-Modifications::doublePlus(int value, int plus)
+int Modifications::doublePlus(int value, int plus)
 {
     return (2 * value) + plus;
 }
 
-int
-Modifications::power(int base, int exponent)
+int Modifications::power(int base, int exponent)
 {
     if (exponent == 0)
         return 1;
@@ -112,38 +107,32 @@ Modifications::power(int base, int exponent)
     return retval;
 }
 
-int
-Modifications::timesTen(int number)
+int Modifications::timesTen(int number)
 {
     return number * 10;
 }
 
-int
-Modifications::increment(int number)
+int Modifications::increment(int number)
 {
     return ++number;
 }
 
-void
-Modifications::exclusiveCppStuff()
+void Modifications::exclusiveCppStuff()
 {
-    cout << __FUNCTION__ << endl;
+    std::cout << __FUNCTION__ << std::endl;
 }
 
-int
-Modifications::cppMultiply(int a, int b)
+int Modifications::cppMultiply(int a, int b)
 {
     return a * b;
 }
 
-const char*
-Modifications::className()
+const char *Modifications::className()
 {
     return "Modifications";
 }
 
-Point
-Modifications::sumPointArray(int arraySize, const Point pointArray[])
+Point Modifications::sumPointArray(int arraySize, const Point pointArray[])
 {
     Point point;
     for (int i = 0; i < arraySize; ++i)
@@ -151,21 +140,18 @@ Modifications::sumPointArray(int arraySize, const Point pointArray[])
     return point;
 }
 
-int
-Modifications::getSize(const void* data, int size)
+int Modifications::getSize(const void *data, int size)
 {
     (void)data;
     return size;
 }
 
-int
-Modifications::sumPointCoordinates(const Point* point)
+int Modifications::sumPointCoordinates(const Point *point)
 {
     return point->x() + point->y();
 }
 
-double
-Modifications::differenceOfPointCoordinates(const Point* pt, bool* ok)
+double Modifications::differenceOfPointCoordinates(const Point *pt, bool *ok)
 {
     if (!pt) {
         *ok = false;
@@ -178,8 +164,7 @@ Modifications::differenceOfPointCoordinates(const Point* pt, bool* ok)
     return result;
 }
 
-bool
-Modifications::nonConversionRuleForArgumentWithDefaultValue(ObjectType** object)
+bool Modifications::nonConversionRuleForArgumentWithDefaultValue(ObjectType **object)
 {
     if (object)
         *object = m_object;
diff --git a/sources/shiboken6/tests/libsample/modifications.h b/sources/shiboken6/tests/libsample/modifications.h
index d757d87b9..5bd1bac47 100644
--- a/sources/shiboken6/tests/libsample/modifications.h
+++ b/sources/shiboken6/tests/libsample/modifications.h
@@ -5,15 +5,18 @@
 #define MODIFICATIONS_H
 
 #include "libsamplemacros.h"
-#include <utility>
 #include "point.h"
 #include "oddbool.h"
 
+#include <utility>
+
 class ObjectType;
 
 class LIBSAMPLE_API Modifications
 {
 public:
+    LIBMINIMAL_DISABLE_COPY_MOVE(Modifications)
+
     Modifications();
     virtual ~Modifications();
 
@@ -61,10 +64,10 @@ public:
     // 'ok' must be removed and the return value will be changed
     // to a tuple (PyObject*) containing the expected result plus
     // the 'ok' value as a Python boolean
-    std::pair<double, double> pointToPair(Point pt, bool* ok);
+    std::pair<double, double> pointToPair(Point pt, bool *ok);
 
     // same as 'pointToPair' except that this time 'ok' is the first argument
-    double multiplyPointCoordsPlusValue(bool* ok, Point pt, double value);
+    double multiplyPointCoordsPlusValue(bool *ok, Point pt, double value);
 
     // completely remove 'plus' from the Python side
     int doublePlus(int value, int plus = 0);
@@ -85,24 +88,25 @@ public:
     int cppMultiply(int a, int b);
 
     // change the name of this virtual method
-    virtual const char* className();
+    virtual const char *className();
 
     Point sumPointArray(int arraySize, const Point pointArray[]);
 
     // Replace 'const void*' by 'ByteArray&'.
-    int getSize(const void* data, int size);
+    int getSize(const void *data, int size);
 
     // Mark the argument with a <no-null-pointer/> tag;
     // the test implementation must expect point never to be null.
-    int sumPointCoordinates(const Point* point);
+    int sumPointCoordinates(const Point *point);
 
     // Modify the return value of a virtual method.
-    virtual double differenceOfPointCoordinates(const Point* pt, bool* ok);
-    double callDifferenceOfPointCoordinates(const Point* pt, bool* ok) { return differenceOfPointCoordinates(pt, ok); }
+    virtual double differenceOfPointCoordinates(const Point *pt, bool *ok);
+    double callDifferenceOfPointCoordinates(const Point *pt, bool *ok)
+    { return differenceOfPointCoordinates(pt, ok); }
 
     // Sets an ObjectType in the argument and returns true.
     bool nonConversionRuleForArgumentWithDefaultValue(ObjectType **object = nullptr);
-    ObjectType* getObject() const { return m_object; }
+    ObjectType *getObject() const { return m_object; }
 
     // Inject code with a %CONVERTTOPYTHON that receives an user's primitive type.
     static inline OddBool passOddBool(OddBool ob) { return ob; }
@@ -118,7 +122,7 @@ public:
     void notifySetAttroCalled();
 
 private:
-    ObjectType* m_object;
+    ObjectType *m_object;
     TestEnum m_enumValue = TestEnumValue1;
     bool m_getAttroCalled = false;
     bool m_setAttroCalled = false;
@@ -127,8 +131,10 @@ private:
 class LIBSAMPLE_API AbstractModifications : public Modifications
 {
 public:
-    AbstractModifications() {}
-    virtual ~AbstractModifications() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(AbstractModifications)
+
+    AbstractModifications() noexcept = default;
+    ~AbstractModifications() override = default;
 
     inline bool invert(bool value) { return !value; }
 
diff --git a/sources/shiboken6/tests/libsample/modified_constructor.cpp b/sources/shiboken6/tests/libsample/modified_constructor.cpp
index d53815243..c39c97738 100644
--- a/sources/shiboken6/tests/libsample/modified_constructor.cpp
+++ b/sources/shiboken6/tests/libsample/modified_constructor.cpp
@@ -8,8 +8,7 @@ ModifiedConstructor::ModifiedConstructor(int first_arg)
     m_stored_value = first_arg;
 }
 
-int
-ModifiedConstructor::retrieveValue()
+int ModifiedConstructor::retrieveValue() const
 {
     return m_stored_value;
 }
diff --git a/sources/shiboken6/tests/libsample/modified_constructor.h b/sources/shiboken6/tests/libsample/modified_constructor.h
index 48cb812a6..a27899f3f 100644
--- a/sources/shiboken6/tests/libsample/modified_constructor.h
+++ b/sources/shiboken6/tests/libsample/modified_constructor.h
@@ -10,8 +10,8 @@ class LIBSAMPLE_API ModifiedConstructor
 {
 public:
 
-    ModifiedConstructor(int first_arg);
-    int retrieveValue();
+    explicit ModifiedConstructor(int first_arg);
+    int retrieveValue() const;
 
 private:
     int m_stored_value;
diff --git a/sources/shiboken6/tests/libsample/multiple_derived.cpp b/sources/shiboken6/tests/libsample/multiple_derived.cpp
index 9797a397b..be535c62f 100644
--- a/sources/shiboken6/tests/libsample/multiple_derived.cpp
+++ b/sources/shiboken6/tests/libsample/multiple_derived.cpp
@@ -3,37 +3,22 @@
 
 #include "multiple_derived.h"
 
-MDerived1::MDerived1() : m_value(100)
-{
-}
+MDerived1::MDerived1() noexcept = default;
 
-MDerived2::MDerived2() : m_value(200)
-{
-}
+MDerived2::MDerived2() noexcept = default;
 
-MDerived3::MDerived3() : m_value(3000)
-{
-}
+MDerived3::MDerived3() noexcept = default;
 
-MDerived4::MDerived4()
-{
-}
+MDerived4::MDerived4() noexcept = default;
 
-MDerived5::MDerived5()
-{
-}
+MDerived5::MDerived5() noexcept = default;
 
-MDerived1*
-MDerived1::transformFromBase1(Base1* self)
+MDerived1 *MDerived1::transformFromBase1(Base1 *self)
 {
-    MDerived1* ptr = dynamic_cast<MDerived1*>(self);
-    return ptr;
+    return dynamic_cast<MDerived1*>(self);
 }
 
-MDerived1*
-MDerived1::transformFromBase2(Base2* self)
+MDerived1 *MDerived1::transformFromBase2(Base2 *self)
 {
-    MDerived1* ptr = dynamic_cast<MDerived1*>(self);
-    return ptr;
+    return dynamic_cast<MDerived1*>(self);
 }
-
diff --git a/sources/shiboken6/tests/libsample/multiple_derived.h b/sources/shiboken6/tests/libsample/multiple_derived.h
index b91fb34cd..8c2143ed6 100644
--- a/sources/shiboken6/tests/libsample/multiple_derived.h
+++ b/sources/shiboken6/tests/libsample/multiple_derived.h
@@ -5,70 +5,86 @@
 #define MDERIVED_H
 
 #include "libsamplemacros.h"
+
 #include <string>
 
 class Base1
 {
 public:
-    Base1() : m_value(1) {}
-    virtual ~Base1() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(Base1)
+
+    Base1() noexcept = default;
+    virtual ~Base1() = default;
+
     virtual int base1Method() { return m_value; }
 
     virtual void publicMethod() {};
+
 private:
-    int m_value;
+    int m_value = 1;
 };
 
 class Base2
 {
 public:
-    Base2() : m_value(2) {}
-    virtual ~Base2() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(Base2)
+
+    Base2() noexcept = default;
+    virtual ~Base2() = default;
     virtual int base2Method() { return m_value; }
+
 private:
-    int m_value;
+    int m_value = 2;
 };
 
 class LIBSAMPLE_API MDerived1 : public Base1, public Base2
 {
 public:
-    MDerived1();
-    ~MDerived1() override {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(MDerived1)
+
+    MDerived1() noexcept;
+    ~MDerived1() override = default;
 
     int mderived1Method() { return m_value; }
     int base1Method () override { return Base1::base1Method() * 10; }
     int base2Method() override { return Base2::base2Method() * 10; }
 
-    inline Base1* castToBase1() { return (Base1*) this; }
-    inline Base2* castToBase2() { return (Base2*) this; }
+    inline Base1 *castToBase1() { return (Base1*) this; }
+    inline Base2 *castToBase2() { return (Base2*) this; }
 
-    static MDerived1* transformFromBase1(Base1 *self);
-    static MDerived1* transformFromBase2(Base2 *self);
+    static MDerived1 *transformFromBase1(Base1 *self);
+    static MDerived1 *transformFromBase2(Base2 *self);
 
 private:
     void publicMethod() override {}
-    int m_value;
+    int m_value = 100;
 };
 
 class SonOfMDerived1 : public MDerived1
 {
 public:
-    SonOfMDerived1() : m_value(0) {}
-    ~SonOfMDerived1() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(SonOfMDerived1)
+
+    SonOfMDerived1() noexcept = default;
+    ~SonOfMDerived1() = default;
 
-    inline MDerived1* castToMDerived1() { return (MDerived1*) this; }
+    inline MDerived1 *castToMDerived1() { return this; }
 
     int sonOfMDerived1Method() { return m_value; }
+
 private:
-    int m_value;
+    int m_value = 0;
 };
 
 class Base3
 {
 public:
-    explicit Base3(int val = 3) : m_value(val) {}
-    virtual ~Base3() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(Base3)
+
+    explicit Base3(int val = 3) noexcept : m_value(val) {}
+    virtual ~Base3() = default;
     int base3Method() { return m_value; }
+
 private:
     int m_value;
 };
@@ -76,80 +92,95 @@ private:
 class Base4
 {
 public:
-    Base4() : m_value(4) {}
-    virtual ~Base4() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(Base4)
+
+    Base4() noexcept = default;
+    virtual ~Base4() = default;
     int base4Method() { return m_value; }
+
 private:
-    int m_value;
+    int m_value = 4;
 };
 
 class Base5
 {
 public:
-    Base5() : m_value(5) {}
-    virtual ~Base5() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(Base5)
+
+    Base5() noexcept = default;
+    virtual ~Base5() = default;
     virtual int base5Method() { return m_value; }
+
 private:
-    int m_value;
+    int m_value = 5;
 };
 
 class Base6
 {
 public:
-    Base6() : m_value(6) {}
-    virtual ~Base6() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(Base6)
+
+    Base6() noexcept = default;
+    virtual ~Base6() = default;
     virtual int base6Method() { return m_value; }
+
 private:
-    int m_value;
+    int m_value = 6;
 };
 
-
 class LIBSAMPLE_API MDerived2 : public Base3, public Base4, public Base5, public Base6
 {
 public:
-    MDerived2();
-    virtual ~MDerived2() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(MDerived2)
+
+    MDerived2() noexcept;
+    virtual ~MDerived2() = default;
 
     inline int base4Method() { return Base3::base3Method() * 10; }
     inline int mderived2Method() { return m_value; }
 
-    inline Base3* castToBase3() { return (Base3*) this; }
-    inline Base4* castToBase4() { return (Base4*) this; }
-    inline Base5* castToBase5() { return (Base5*) this; }
-    inline Base6* castToBase6() { return (Base6*) this; }
+    inline Base3 *castToBase3() { return this; }
+    inline Base4 *castToBase4() { return this; }
+    inline Base5 *castToBase5() { return this; }
+    inline Base6 *castToBase6() { return this; }
 
 private:
-    int m_value;
+    int m_value = 200;
 };
 
 class LIBSAMPLE_API MDerived3 : public MDerived1, public MDerived2
 {
 public:
-    MDerived3();
-    virtual ~MDerived3() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(MDerived3)
+
+    MDerived3() noexcept;
+    virtual ~MDerived3() = default;
 
     inline virtual int mderived3Method() { return m_value; }
 
-    inline MDerived1* castToMDerived1() { return (MDerived1*) this; }
-    inline MDerived2* castToMDerived2() { return (MDerived2*) this; }
+    inline MDerived1 *castToMDerived1() { return this; }
+    inline MDerived2 *castToMDerived2() { return this; }
 
-    inline Base3* castToBase3() { return (Base3*) this; }
+    inline Base3 *castToBase3() { return (Base3*) this; }
 
 private:
-    int m_value;
+    int m_value = 3000;
 };
 
 class LIBSAMPLE_API MDerived4 : public Base3, public Base4
 {
 public:
-    MDerived4();
-    ~MDerived4() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(MDerived4)
+
+    MDerived4() noexcept;
+    ~MDerived4() = default;
 
     inline int mderived4Method() { return 0; }
     inline int justDummyMethod() { return m_value; }
 
-    inline Base3* castToBase3() { return (Base3*) this; }
-    inline Base4* castToBase4() { return (Base4*) this; }
+    inline Base3 *castToBase3() { return this; }
+    inline Base4 *castToBase4() { return this; }
+
 private:
     int m_value;
 };
@@ -157,14 +188,15 @@ private:
 class LIBSAMPLE_API MDerived5 : public Base3, public Base4
 {
 public:
-    MDerived5();
-    virtual ~MDerived5() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(MDerived5)
+
+    MDerived5() noexcept;
+    virtual ~MDerived5() = default;
 
     virtual int mderived5Method() { return 0; }
 
-    inline Base3* castToBase3() { return (Base3*) this; }
-    inline Base4* castToBase4() { return (Base4*) this; }
+    inline Base3 *castToBase3() { return this; }
+    inline Base4 *castToBase4() { return this; }
 };
 
 #endif // MDERIVED_H
-
diff --git a/sources/shiboken6/tests/libsample/noimplicitconversion.h b/sources/shiboken6/tests/libsample/noimplicitconversion.h
index e7d738037..a0b91380b 100644
--- a/sources/shiboken6/tests/libsample/noimplicitconversion.h
+++ b/sources/shiboken6/tests/libsample/noimplicitconversion.h
@@ -13,9 +13,12 @@ class NoImplicitConversion
 public:
     explicit NoImplicitConversion(int objId) : m_objId(objId) {}
     inline int objId() const { return m_objId; }
-    inline static int receivesNoImplicitConversionByValue(NoImplicitConversion arg) { return arg.m_objId; }
-    inline static int receivesNoImplicitConversionByPointer(NoImplicitConversion* arg) { return arg->m_objId; }
-    inline static int receivesNoImplicitConversionByReference(NoImplicitConversion& arg) { return arg.m_objId; }
+    inline static int receivesNoImplicitConversionByValue(NoImplicitConversion arg)
+    { return arg.m_objId; }
+    inline static int receivesNoImplicitConversionByPointer(NoImplicitConversion *arg)
+    { return arg->m_objId; }
+    inline static int receivesNoImplicitConversionByReference(NoImplicitConversion &arg)
+    { return arg.m_objId; }
 private:
     int m_objId;
 };
diff --git a/sources/shiboken6/tests/libsample/nondefaultctor.h b/sources/shiboken6/tests/libsample/nondefaultctor.h
index c410515ad..fa97b8859 100644
--- a/sources/shiboken6/tests/libsample/nondefaultctor.h
+++ b/sources/shiboken6/tests/libsample/nondefaultctor.h
@@ -8,13 +8,16 @@
 
 class NonDefaultCtor
 {
-    int m_value;
 public:
-    NonDefaultCtor(int value) : m_value(value)
+    LIBMINIMAL_DEFAULT_COPY_MOVE(NonDefaultCtor)
+
+    explicit NonDefaultCtor(int value) noexcept : m_value(value)
     {
     }
 
-    inline  int value()
+    virtual ~NonDefaultCtor() = default;
+
+    inline int value() const
     {
         return m_value;
     }
@@ -44,7 +47,8 @@ public:
         return returnMyselfVirtual();
     }
 
-    virtual ~NonDefaultCtor() {}
+private:
+    int m_value;
 };
 
-#endif
+#endif // NONDEFAULTCTOR_H
diff --git a/sources/shiboken6/tests/libsample/nontypetemplate.h b/sources/shiboken6/tests/libsample/nontypetemplate.h
index d3bc7fb8a..e41c21604 100644
--- a/sources/shiboken6/tests/libsample/nontypetemplate.h
+++ b/sources/shiboken6/tests/libsample/nontypetemplate.h
@@ -21,7 +21,7 @@ private:
     int m_array[Size];
 };
 
-typedef IntArray<2> IntArray2;
-typedef IntArray<3> IntArray3;
+using IntArray2 = IntArray<2>;
+using IntArray3 = IntArray<3>;
 
 #endif // NONTYPETEMPLATE_H
diff --git a/sources/shiboken6/tests/libsample/null.h b/sources/shiboken6/tests/libsample/null.h
index 9a618095c..945a89fa2 100644
--- a/sources/shiboken6/tests/libsample/null.h
+++ b/sources/shiboken6/tests/libsample/null.h
@@ -8,12 +8,12 @@ class Null
 {
 public:
     Null(bool value) : m_isNull(value) {}
-    Null() : m_isNull(false) {}
+    Null() = default;
+
     void setIsNull(bool flag) { m_isNull = flag; }
 
 private:
-    bool m_isNull;
+    bool m_isNull = false;
 };
 
-#endif // STR_H
-
+#endif // NULL_H
diff --git a/sources/shiboken6/tests/libsample/objectmodel.cpp b/sources/shiboken6/tests/libsample/objectmodel.cpp
index a211d2969..56ed86577 100644
--- a/sources/shiboken6/tests/libsample/objectmodel.cpp
+++ b/sources/shiboken6/tests/libsample/objectmodel.cpp
@@ -3,14 +3,12 @@
 
 #include "objectmodel.h"
 
-void
-ObjectModel::setData(ObjectType* data)
+void ObjectModel::setData(ObjectType *data)
 {
     m_data = data;
 }
 
-ObjectType*
-ObjectModel::data() const
+ObjectType *ObjectModel::data() const
 {
     return m_data;
 }
diff --git a/sources/shiboken6/tests/libsample/objectmodel.h b/sources/shiboken6/tests/libsample/objectmodel.h
index 063404460..6d2f97aee 100644
--- a/sources/shiboken6/tests/libsample/objectmodel.h
+++ b/sources/shiboken6/tests/libsample/objectmodel.h
@@ -11,11 +11,10 @@ class LIBSAMPLE_API ObjectModel : public ObjectType
 {
 public:
     explicit ObjectModel(ObjectType *parent = nullptr)
-        : ObjectType(parent), m_data(nullptr)
-    {}
+        : ObjectType(parent) {}
 
-    void setData(ObjectType* data);
-    virtual ObjectType* data() const;
+    void setData(ObjectType *data);
+    virtual ObjectType *data() const;
 
     // The MethodCalled enum and related static methods were created to
     // test bug #630 [http://bugs.openbossa.org/show_bug.cgi?id=630]
@@ -26,8 +25,7 @@ public:
 private:
     // The model holds only one piece of data.
     // (This is just a test after all.)
-    ObjectType* m_data;
+    ObjectType *m_data = nullptr;
 };
 
 #endif // OBJECTMODEL_H
-
diff --git a/sources/shiboken6/tests/libsample/objecttype.cpp b/sources/shiboken6/tests/libsample/objecttype.cpp
index 1e3920734..fa3e7357c 100644
--- a/sources/shiboken6/tests/libsample/objecttype.cpp
+++ b/sources/shiboken6/tests/libsample/objecttype.cpp
@@ -3,44 +3,36 @@
 
 #include "objecttype.h"
 #include "objecttypelayout.h"
+
 #include <algorithm>
 #include <iostream>
 #include <string>
 #include <assert.h>
 
-#include <algorithm>
-
-using namespace std;
-
-ObjectType::ObjectType(ObjectType* parent) : m_parent(nullptr), m_layout(nullptr), m_call_id(-1)
+ObjectType::ObjectType(ObjectType *parent)
 {
     setParent(parent);
 }
 
+ObjectType::ObjectType(ObjectType &&) noexcept = default;
+ObjectType &ObjectType::operator=(ObjectType &&) noexcept = default;
+
 ObjectType::~ObjectType()
 {
     for (auto *o : m_children)
         delete o;
 }
 
-ObjectType*
-ObjectType::createWithChild()
+ObjectType *ObjectType::createWithChild()
 {
-    ObjectType* parent = create();
-    ObjectType* child = create();
+    ObjectType *parent = create();
+    ObjectType *child = create();
     child->setObjectName("child");
     child->setParent(parent);
     return parent;
 }
 
-const ObjectType *ObjectType::defaultInstance()
-{
-    static ObjectType result;
-    return &result;
-}
-
-void
-ObjectType::removeChild(ObjectType* child)
+void ObjectType::removeChild(ObjectType *child)
 {
     if (!child)
         return;
@@ -52,8 +44,7 @@ ObjectType::removeChild(ObjectType* child)
     }
 }
 
-ObjectType*
-ObjectType::takeChild(ObjectType* child)
+ObjectType *ObjectType::takeChild(ObjectType *child)
 {
     if (!child)
         return nullptr;
@@ -67,8 +58,7 @@ ObjectType::takeChild(ObjectType* child)
     return nullptr;
 }
 
-ObjectType*
-ObjectType::takeChild(const Str& name)
+ObjectType *ObjectType::takeChild(const Str &name)
 {
     return takeChild(findChild(name));
 
@@ -82,15 +72,13 @@ ObjectTypeList::iterator ObjectType::findChildByName(const Str &name)
                         });
 }
 
-ObjectType*
-ObjectType::findChild(const Str& name)
+ObjectType *ObjectType::findChild(const Str &name)
 {
     auto it = findChildByName(name);
     return it != m_children.end() ? *it : nullptr;
 }
 
-void
-ObjectType::killChild(const Str& name)
+void ObjectType::killChild(const Str &name)
 {
     auto it = findChildByName(name);
     if (it != m_children.end()) {
@@ -100,8 +88,7 @@ ObjectType::killChild(const Str& name)
     }
 }
 
-void
-ObjectType::setParent(ObjectType* parent)
+void ObjectType::setParent(ObjectType *parent)
 {
     if (m_parent == parent)
         return;
@@ -114,20 +101,17 @@ ObjectType::setParent(ObjectType* parent)
         m_parent->m_children.push_back(this);
 }
 
-void
-ObjectType::setObjectName(const Str& name)
+void ObjectType::setObjectName(const Str &name)
 {
     m_objectName = name;
 }
 
-Str
-ObjectType::objectName() const
+Str ObjectType::objectName() const
 {
     return m_objectName;
 }
 
-bool
-ObjectType::causeEvent(Event::EventType eventType)
+bool ObjectType::causeEvent(Event::EventType eventType)
 {
     Event e(eventType);
     return event(&e);
@@ -138,8 +122,7 @@ bool ObjectType::event(Event *)
     return true;
 }
 
-int
-ObjectType::processEvent(ObjectTypeList objects, Event *event)
+int ObjectType::processEvent(ObjectTypeList objects, Event *event)
 {
     return std::count_if(objects.begin(), objects.end(),
                          [event] (ObjectType *o) {
@@ -147,8 +130,7 @@ ObjectType::processEvent(ObjectTypeList objects, Event *event)
                          });
 }
 
-void
-ObjectType::callInvalidateEvent(Event* event)
+void ObjectType::callInvalidateEvent(Event *event)
 {
     invalidateEvent(event);
 }
@@ -157,32 +139,34 @@ void ObjectType::invalidateEvent(Event *)
 {
 }
 
-void
-ObjectType::setLayout(ObjectTypeLayout* l)
+void ObjectType::setLayout(ObjectTypeLayout *l)
 {
     if (!l) {
-        cerr << "[WARNING] ObjectType::setLayout: Cannot set layout to 0." << endl;
+        std::cerr << "[WARNING] ObjectType::setLayout: Cannot set layout to 0.\n";
         return;
     }
 
     if (layout()) {
         if (layout() != l) {
-            cerr << "[WARNING] ObjectType::setLayout: Attempting to set ObjectTypeLayout '" << l->objectName().cstring();
-            cerr << "' on ObjectType '" << objectName().cstring() << "', which already has a layout." << endl;
+            std::cerr << "[WARNING] ObjectType::setLayout: Attempting to set ObjectTypeLayout '"
+                << l->objectName().cstring()
+                << "' on ObjectType '" << objectName().cstring()
+                << "', which already has a layout.\n";
         }
         return;
     }
 
-    ObjectType* oldParent = l->parent();
+    ObjectType *oldParent = l->parent();
     if (oldParent && oldParent != this) {
         if (oldParent->isLayoutType()) {
-            cerr << "[WARNING] ObjectType::setLayout: Attempting to set ObjectTypeLayout '" << l->objectName().cstring();
-            cerr << "' on ObjectType '" << objectName().cstring() << "', when the ObjectTypeLayout already has a parent layout." << endl;
+            std::cerr << "[WARNING] ObjectType::setLayout: Attempting to set ObjectTypeLayout '"
+                << l->objectName().cstring()
+                << "' on ObjectType '" << objectName().cstring()
+                << "', when the ObjectTypeLayout already has a parent layout.\n";
             return;
-        } else {
-            // Steal the layout from an ObjectType parent.
-            oldParent->takeLayout();
         }
+        // Steal the layout from an ObjectType parent.
+        oldParent->takeLayout();
     }
 
     m_layout = l;
@@ -192,9 +176,9 @@ ObjectType::setLayout(ObjectTypeLayout* l)
     }
 }
 
-ObjectTypeLayout* ObjectType::takeLayout()
+ObjectTypeLayout *ObjectType::takeLayout()
 {
-    ObjectTypeLayout* l = layout();
+    ObjectTypeLayout *l = layout();
     if (!l)
         return nullptr;
     m_layout = nullptr;
@@ -202,15 +186,14 @@ ObjectTypeLayout* ObjectType::takeLayout()
     return l;
 }
 
-unsigned int
-objectTypeHash(const ObjectType* objectType)
+unsigned int objectTypeHash(const ObjectType *objectType)
 {
     return reinterpret_cast<std::size_t>(objectType);
 }
 
 unsigned char ObjectType::callWithEnum(const Str &, Event::EventType, unsigned char value)
 {
-    return value*value;
+    return value * value;
 }
 
 unsigned char ObjectType::callWithEnum(const Str &, unsigned char value)
@@ -218,23 +201,20 @@ unsigned char ObjectType::callWithEnum(const Str &, unsigned char value)
     return value;
 }
 
-void
-ObjectType::setObjectSplittedName(const char*, const Str& prefix, const Str& suffix)
+void ObjectType::setObjectSplittedName(const char *, const Str &prefix, const Str &suffix)
 {
     std::string result(prefix.cstring());
     result += suffix.cstring();
     m_objectName = result.c_str();
 }
 
-void
-ObjectType::setObjectNameWithSize(const char*, int size, const Str& name)
+void ObjectType::setObjectNameWithSize(const char *, int size, const Str &name)
 {
     std::string result(name.cstring(), size);
     m_objectName = result.c_str();
 }
 
-void
-ObjectType::setObjectNameWithSize(const Str& name, int size)
+void ObjectType::setObjectNameWithSize(const Str &name, int size)
 {
     setObjectNameWithSize("", size, name);
 }
@@ -254,34 +234,29 @@ int ObjectType::callId() const
     return m_call_id;
 }
 
-
 void ObjectType::callVirtualCreateChild()
 {
-    ObjectType* fake_parent = new ObjectType();
-    ObjectType* fake_child = createChild(fake_parent);
+    auto *fake_parent = new ObjectType();
+    ObjectType *fake_child = createChild(fake_parent);
     assert(fake_child->isPython());
     (void)fake_child;
     delete fake_parent;
 }
 
-ObjectType* ObjectType::createChild(ObjectType* parent)
+ObjectType *ObjectType::createChild(ObjectType *parent)
 {
     return new ObjectType(parent);
 }
 
 std::size_t ObjectType::createObjectType()
 {
-    void* addr = new ObjectType();
+    void *addr = new ObjectType();
     return (std::size_t) addr;
 }
 
-OtherBase::~OtherBase()
-{
-}
+OtherBase::~OtherBase() = default;
 
-ObjectTypeDerived::~ObjectTypeDerived()
-{
-}
+ObjectTypeDerived::~ObjectTypeDerived() = default;
 
 bool ObjectTypeDerived::event(Event *)
 {
diff --git a/sources/shiboken6/tests/libsample/objecttype.h b/sources/shiboken6/tests/libsample/objecttype.h
index 221fb7eea..498556459 100644
--- a/sources/shiboken6/tests/libsample/objecttype.h
+++ b/sources/shiboken6/tests/libsample/objecttype.h
@@ -4,13 +4,12 @@
 #ifndef OBJECTTYPE_H
 #define OBJECTTYPE_H
 
-#include <list>
 #include "str.h"
 #include "null.h"
 
 #include "libsamplemacros.h"
 
-#include <stddef.h>
+#include <list>
 
 struct Event
 {
@@ -26,8 +25,8 @@ struct Event
         Value2
     };
 
-    Event(EventType eventType) : m_eventType(eventType) {}
-    EventType eventType() { return m_eventType; }
+    explicit Event(EventType eventType) : m_eventType(eventType) {}
+    EventType eventType() const { return m_eventType; }
 
     void setEventType(EventType et) { m_eventType = et; }
     void setEventTypeByConstRef(const EventType &et) { m_eventType = et; }
@@ -49,67 +48,72 @@ public:
 
     explicit ObjectType(ObjectType *parent = nullptr);
     virtual ~ObjectType();
+    ObjectType(const ObjectType &) = delete;
+    ObjectType &operator=(const ObjectType &) = delete;
+    ObjectType(ObjectType &&) noexcept;
+    ObjectType &operator=(ObjectType &&) noexcept;
 
     // factory method
-    inline static ObjectType* create() { return new ObjectType(); }
-    static ObjectType* createWithChild();
-
-    static const ObjectType *defaultInstance();
-
-    void setParent(ObjectType* parent);
-    inline ObjectType* parent() const { return m_parent; }
-    inline const ObjectTypeList& children() const { return m_children; }
-    void killChild(const Str& name);
-    void removeChild(ObjectType* child);
-    ObjectType* takeChild(ObjectType* child);
-    virtual ObjectType* takeChild(const Str& name);
-    ObjectType* findChild(const Str& name);
+    inline static ObjectType *create() { return new ObjectType(); }
+    static ObjectType *createWithChild();
+
+    void setParent(ObjectType *parent);
+    inline ObjectType *parent() const { return m_parent; }
+    inline const ObjectTypeList &children() const { return m_children; }
+    void killChild(const Str &name);
+    void removeChild(ObjectType *child);
+    ObjectType *takeChild(ObjectType *child);
+    virtual ObjectType *takeChild(const Str &name);
+    ObjectType *findChild(const Str &name);
 
     Str objectName() const;
-    void setObjectName(const Str& name);
+    void setObjectName(const Str &name);
 
     inline Identifier identifier() const { return reinterpret_cast<Identifier>(this); }
 
     bool causeEvent(Event::EventType eventType);
 
     // Returns true if the event is processed.
-    virtual bool event(Event* event);
+    virtual bool event(Event *event);
     static int processEvent(ObjectTypeList objects, Event *event);
 
-    void callInvalidateEvent(Event* event);
+    void callInvalidateEvent(Event *event);
     virtual void invalidateEvent(Event *event);
 
     // This nonsense method emulate QWidget.setLayout method
     // All layout objects will became children of this object.
-    void setLayout(ObjectTypeLayout* layout);
-    inline ObjectTypeLayout* layout() const { return m_layout; }
+    void setLayout(ObjectTypeLayout *layout);
+    inline ObjectTypeLayout *layout() const { return m_layout; }
 
     // This method should be reimplemented by ObjectTypeLayout.
     virtual bool isLayoutType() { return false; }
 
-    unsigned char callWithEnum(const Str& prefix, Event::EventType type, unsigned char value=80);
-    unsigned char callWithEnum(const Str& prefix, unsigned char value=0);
+    unsigned char callWithEnum(const Str &prefix, Event::EventType type,
+                               unsigned char value=80);
+    unsigned char callWithEnum(const Str &prefix, unsigned char value=0);
 
     //Functions used in test with named arguments
-    void setObjectSplittedName(const char*, const Str& prefix = Str("<unk"), const Str& suffix = Str("nown>"));
-    void setObjectNameWithSize(const char*, int size=9, const Str& name = Str("<unknown>"));
-    void setObjectNameWithSize(const Str& name = Str("<unknown>"), int size=9);
+    void setObjectSplittedName(const char *, const Str &prefix = Str("<unk"),
+                               const Str &suffix = Str("nown>"));
+    void setObjectNameWithSize(const char *, int size=9,
+                               const Str &name = Str("<unknown>"));
+    void setObjectNameWithSize(const Str &name = Str("<unknown>"), int size = 9);
 
     //Function used to confuse the generator when two values accept Null as arg
     void setObject(ObjectType *);
-    void setObject(const Null&);
+    void setObject(const Null &);
     int callId() const;
 
     //Function used to create a parent from C++
     virtual bool isPython() { return false; }
     void callVirtualCreateChild();
-    virtual ObjectType* createChild(ObjectType* parent);
+    virtual ObjectType *createChild(ObjectType *parent);
     static std::size_t createObjectType();
 
     //return a parent from C++
-    ObjectType* getCppParent() {
+    ObjectType *getCppParent() {
         if (!m_parent) {
-            ObjectType* parent = new ObjectType();
+            ObjectType *parent = new ObjectType();
             setParent(parent);
         }
         return m_parent;
@@ -124,41 +128,39 @@ public:
 
     // nextInFocusChain simply returns the parent to test object cycles; the parent
     // may be returned by the QWidget's implementation but isn't always returned
-    ObjectType* nextInFocusChain() { return m_parent; }
+    ObjectType *nextInFocusChain() { return m_parent; }
 
 private:
-    ObjectType(const ObjectType&);
-    ObjectType& operator=(const ObjectType&);
-
-    ObjectTypeLayout* takeLayout();
+    ObjectTypeLayout *takeLayout();
     ObjectTypeList::iterator findChildByName(const Str &name);
 
     Str m_objectName;
-    ObjectType* m_parent;
+    ObjectType *m_parent = nullptr;
     ObjectTypeList m_children;
 
-    ObjectTypeLayout* m_layout;
-
-
+    ObjectTypeLayout *m_layout = nullptr;
     //used on overload null test
-    int m_call_id;
+    int m_call_id = -1;
 };
 
-LIBSAMPLE_API unsigned int objectTypeHash(const ObjectType* objectType);
+LIBSAMPLE_API unsigned int objectTypeHash(const ObjectType *objectType);
 
 class LIBSAMPLE_API OtherBase {
 public:
-    OtherBase() {};
+    LIBMINIMAL_DISABLE_COPY_MOVE(OtherBase)
+
+    OtherBase() noexcept = default;
     virtual ~OtherBase();
 };
 
 class LIBSAMPLE_API ObjectTypeDerived: public ObjectType, public OtherBase {
 public:
-    ObjectTypeDerived(): ObjectType(), OtherBase() {};
+    LIBMINIMAL_DISABLE_COPY_MOVE(ObjectTypeDerived)
 
-    bool event(Event* event) override;
+    ObjectTypeDerived() noexcept = default;
+
+    bool event(Event *event) override;
     ~ObjectTypeDerived() override;
 };
 
 #endif // OBJECTTYPE_H
-
diff --git a/sources/shiboken6/tests/libsample/objecttypebyvalue.h b/sources/shiboken6/tests/libsample/objecttypebyvalue.h
index 0d7ac0160..7b12ff945 100644
--- a/sources/shiboken6/tests/libsample/objecttypebyvalue.h
+++ b/sources/shiboken6/tests/libsample/objecttypebyvalue.h
@@ -3,13 +3,15 @@
 
 #ifndef OBJECTTYPEBYVALUE_H
 #define OBJECTTYPEBYVALUE_H
-#include <list>
+
 #include "protected.h"
 
+#include <list>
+
 class ObjectTypeByValue
 {
 public:
-    ObjectTypeByValue returnSomeKindOfMe() { return ObjectTypeByValue(); }
+    ObjectTypeByValue returnSomeKindOfMe() { return {}; }
     void acceptKindOfMeAsValue(ObjectTypeByValue kindOfMe);
 
     void acceptListOfObjectTypeByValue(std::list<ObjectTypeByValue> listOfMe);
diff --git a/sources/shiboken6/tests/libsample/objecttypeholder.cpp b/sources/shiboken6/tests/libsample/objecttypeholder.cpp
index 076023470..c0950d09c 100644
--- a/sources/shiboken6/tests/libsample/objecttypeholder.cpp
+++ b/sources/shiboken6/tests/libsample/objecttypeholder.cpp
@@ -3,14 +3,14 @@
 
 #include "objecttypeholder.h"
 
-ObjectTypeHolder::ObjectTypeHolder(const char* objectName)
+ObjectTypeHolder::ObjectTypeHolder(const char *objectName)
 {
-    auto object = new ObjectType();
+    auto *object = new ObjectType();
     object->setObjectName(objectName);
     m_objectType = object;
 }
 
-ObjectTypeHolder::ObjectTypeHolder(const ObjectType *object) :
+ObjectTypeHolder::ObjectTypeHolder(const ObjectType *object) noexcept :
     m_objectType(object)
 {
 }
@@ -20,14 +20,12 @@ ObjectTypeHolder::~ObjectTypeHolder()
     delete m_objectType;
 }
 
-Str
-ObjectTypeHolder::passObjectTypeAsReference(const ObjectType& objectType)
+Str ObjectTypeHolder::passObjectTypeAsReference(const ObjectType &objectType)
 {
     return objectType.objectName();
 }
 
-Str
-ObjectTypeHolder::callPassObjectTypeAsReference()
+Str ObjectTypeHolder::callPassObjectTypeAsReference()
 {
     return passObjectTypeAsReference(*m_objectType);
 }
diff --git a/sources/shiboken6/tests/libsample/objecttypeholder.h b/sources/shiboken6/tests/libsample/objecttypeholder.h
index f0ddd97b2..190664608 100644
--- a/sources/shiboken6/tests/libsample/objecttypeholder.h
+++ b/sources/shiboken6/tests/libsample/objecttypeholder.h
@@ -11,17 +11,19 @@
 class LIBSAMPLE_API ObjectTypeHolder
 {
 public:
-    explicit ObjectTypeHolder(const char* objectName);
-    explicit ObjectTypeHolder(const ObjectType *object = ObjectType::defaultInstance());
+    LIBMINIMAL_DISABLE_COPY_MOVE(ObjectTypeHolder)
+
+    explicit ObjectTypeHolder(const char *objectName);
+    explicit ObjectTypeHolder(const ObjectType *object) noexcept;
     virtual ~ObjectTypeHolder();
 
-    const ObjectType* getObjecType() { return m_objectType; }
+    const ObjectType *getObjectType() const { return m_objectType; }
 
-    virtual Str passObjectTypeAsReference(const ObjectType& objectType);
+    virtual Str passObjectTypeAsReference(const ObjectType &objectType);
     Str callPassObjectTypeAsReference();
 
 private:
    const ObjectType *m_objectType;
 };
 
-#endif
+#endif // OBJECTTYPEHOLDER_H
diff --git a/sources/shiboken6/tests/libsample/objecttypelayout.cpp b/sources/shiboken6/tests/libsample/objecttypelayout.cpp
index 2fbd20ccf..3fa02917c 100644
--- a/sources/shiboken6/tests/libsample/objecttypelayout.cpp
+++ b/sources/shiboken6/tests/libsample/objecttypelayout.cpp
@@ -2,17 +2,16 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "objecttypelayout.h"
-#include <iostream>
 
-using namespace std;
+#include <iostream>
 
-void ObjectTypeLayout::addObject(ObjectType* obj)
+void ObjectTypeLayout::addObject(ObjectType *obj)
 {
     if (obj->isLayoutType()) {
-        ObjectTypeLayout* l = reinterpret_cast<ObjectTypeLayout*>(obj);
+        auto *l = reinterpret_cast<ObjectTypeLayout*>(obj);
         if (l->parent()) {
-            cerr << "[WARNING] ObjectTypeLayout::addObject: layout '" << l->objectName().cstring();
-            cerr << "' already has a parent." << endl;
+            std::cerr << "[WARNING] ObjectTypeLayout::addObject: layout '"
+                << l->objectName().cstring() << "' already has a parent.\n";
             return;
         }
 
@@ -25,12 +24,12 @@ void ObjectTypeLayout::addObject(ObjectType* obj)
     m_objects.push_back(obj);
 }
 
-std::list< ObjectType* > ObjectTypeLayout::objects() const
+std::list<ObjectType*> ObjectTypeLayout::objects() const
 {
     return m_objects;
 }
 
-void ObjectTypeLayout::reparentChildren(ObjectType* parent)
+void ObjectTypeLayout::reparentChildren(ObjectType *parent)
 {
     for (auto *o : m_objects) {
         if (o->isLayoutType())
@@ -39,4 +38,3 @@ void ObjectTypeLayout::reparentChildren(ObjectType* parent)
             o->setParent(parent);
     }
 }
-
diff --git a/sources/shiboken6/tests/libsample/objecttypelayout.h b/sources/shiboken6/tests/libsample/objecttypelayout.h
index 98eb30946..0aa9fad6e 100644
--- a/sources/shiboken6/tests/libsample/objecttypelayout.h
+++ b/sources/shiboken6/tests/libsample/objecttypelayout.h
@@ -6,6 +6,7 @@
 
 #include "libsamplemacros.h"
 #include "objecttype.h"
+
 #include <list>
 
 class ObjectType;
@@ -13,19 +14,19 @@ class ObjectType;
 class LIBSAMPLE_API ObjectTypeLayout : public ObjectType
 {
 public:
-    void addObject(ObjectType* obj);
+    void addObject(ObjectType *obj);
     std::list<ObjectType*> objects() const;
 
     bool isLayoutType() override { return true; }
-    inline static ObjectTypeLayout* create() { return new ObjectTypeLayout(); }
+    inline static ObjectTypeLayout *create() { return new ObjectTypeLayout(); }
+
+    ObjectType *takeChild(const Str &name) override { return ObjectType::takeChild(name); }
 
-    ObjectType* takeChild(const Str& name) override { return ObjectType::takeChild(name); }
 private:
     std::list<ObjectType*> m_objects;
 
-    void reparentChildren(ObjectType* parent);
-    friend LIBSAMPLE_API void ObjectType::setLayout(ObjectTypeLayout* l);
+    void reparentChildren(ObjectType *parent);
+    friend LIBSAMPLE_API void ObjectType::setLayout(ObjectTypeLayout *l);
 };
 
 #endif // OBJECTTYPELAYOUT_H
-
diff --git a/sources/shiboken6/tests/libsample/objecttypeoperators.cpp b/sources/shiboken6/tests/libsample/objecttypeoperators.cpp
index 05f229a81..c78387a3e 100644
--- a/sources/shiboken6/tests/libsample/objecttypeoperators.cpp
+++ b/sources/shiboken6/tests/libsample/objecttypeoperators.cpp
@@ -7,32 +7,32 @@ ObjectTypeOperators::ObjectTypeOperators(const std::string key) : m_key(key)
 {
 }
 
-bool ObjectTypeOperators::operator==(const ObjectTypeOperators& other) const
+bool ObjectTypeOperators::operator==(const ObjectTypeOperators &other) const
 {
     return m_key == other.m_key;
 }
 
-const ObjectTypeOperators& ObjectTypeOperators::operator<(const ObjectTypeOperators& other) const
+const ObjectTypeOperators &ObjectTypeOperators::operator<(const ObjectTypeOperators &other) const
 {
     return m_key < other.m_key ? *this : other;
 }
 
-bool operator==(const ObjectTypeOperators* obj, const std::string& str)
+bool operator==(const ObjectTypeOperators *obj, const std::string &str)
 {
     return obj->key() == str;
 }
 
-bool operator==(const std::string& str, const ObjectTypeOperators* obj)
+bool operator==(const std::string &str, const ObjectTypeOperators *obj)
 {
     return str == obj->key();
 }
 
-std::string operator+(const ObjectTypeOperators* obj, const std::string& str)
+std::string operator+(const ObjectTypeOperators *obj, const std::string &str)
 {
     return obj->key() + str;
 }
 
-std::string operator+(const std::string& str, const ObjectTypeOperators* obj)
+std::string operator+(const std::string &str, const ObjectTypeOperators *obj)
 {
     return str + obj->key();
 }
diff --git a/sources/shiboken6/tests/libsample/objecttypeoperators.h b/sources/shiboken6/tests/libsample/objecttypeoperators.h
index b768359a3..6144952ca 100644
--- a/sources/shiboken6/tests/libsample/objecttypeoperators.h
+++ b/sources/shiboken6/tests/libsample/objecttypeoperators.h
@@ -5,32 +5,32 @@
 #define OBJECTTYPEOPERATORS_H
 
 #include "libsamplemacros.h"
+
 #include <string>
 
 class LIBSAMPLE_API ObjectTypeOperators
 {
 public:
+    LIBMINIMAL_DISABLE_COPY_MOVE(ObjectTypeOperators)
+
     explicit ObjectTypeOperators(const std::string key);
-    virtual ~ObjectTypeOperators() {}
+    virtual ~ObjectTypeOperators() = default;
 
-    bool operator==(const ObjectTypeOperators& other) const;
-    const ObjectTypeOperators& operator<(const ObjectTypeOperators& other) const;
+    bool operator==(const ObjectTypeOperators &other) const;
+    const ObjectTypeOperators &operator<(const ObjectTypeOperators &other) const;
 
     // chaos!
-    virtual void operator>(const ObjectTypeOperators&) { m_key.append("operator>"); }
+    virtual void operator>(const ObjectTypeOperators &) { m_key.append("operator>"); }
 
     std::string key() const { return m_key; }
 
 private:
     std::string m_key;
-
-    ObjectTypeOperators(ObjectTypeOperators&);
-    ObjectTypeOperators& operator=(ObjectTypeOperators&);
 };
 
-LIBSAMPLE_API bool operator==(const ObjectTypeOperators* obj, const std::string& str);
-LIBSAMPLE_API bool operator==(const std::string& str, const ObjectTypeOperators* obj);
-LIBSAMPLE_API std::string operator+(const ObjectTypeOperators* obj, const std::string& str);
-LIBSAMPLE_API std::string operator+(const std::string& str, const ObjectTypeOperators* obj);
+LIBSAMPLE_API bool operator==(const ObjectTypeOperators *obj, const std::string &str);
+LIBSAMPLE_API bool operator==(const std::string &str, const ObjectTypeOperators *obj);
+LIBSAMPLE_API std::string operator+(const ObjectTypeOperators *obj, const std::string &str);
+LIBSAMPLE_API std::string operator+(const std::string &str, const ObjectTypeOperators *obj);
 
 #endif // OBJECTTYPEOPERATORS_H
diff --git a/sources/shiboken6/tests/libsample/objectview.cpp b/sources/shiboken6/tests/libsample/objectview.cpp
index 5717053a7..1b727f88c 100644
--- a/sources/shiboken6/tests/libsample/objectview.cpp
+++ b/sources/shiboken6/tests/libsample/objectview.cpp
@@ -5,25 +5,20 @@
 #include "objectmodel.h"
 #include "str.h"
 
-Str
-ObjectView::displayModelData()
+Str ObjectView::displayModelData()
 {
     if (!m_model)
-        return Str("(NULL)");
+        return {"(NULL)"};
     return Str("Name: %VAR").arg(m_model->objectName());
 }
 
-void
-ObjectView::modifyModelData(Str& data)
+void ObjectView::modifyModelData(Str &data)
 {
     if (m_model)
         m_model->setObjectName(data);
 }
 
-
-ObjectType*
-ObjectView::getRawModelData()
+ObjectType *ObjectView::getRawModelData()
 {
     return m_model->data();
 }
-
diff --git a/sources/shiboken6/tests/libsample/objectview.h b/sources/shiboken6/tests/libsample/objectview.h
index 1de474ff2..2567deee5 100644
--- a/sources/shiboken6/tests/libsample/objectview.h
+++ b/sources/shiboken6/tests/libsample/objectview.h
@@ -13,21 +13,19 @@ class ObjectModel;
 class LIBSAMPLE_API ObjectView : public ObjectType
 {
 public:
-    ObjectView(ObjectModel *model = nullptr, ObjectType *parent = nullptr)
-        : ObjectType(parent), m_model(model)
-    {}
+    explicit ObjectView(ObjectModel *model = nullptr, ObjectType *parent = nullptr)
+        : ObjectType(parent), m_model(model) {}
 
-    inline void setModel(ObjectModel* model) { m_model = model; }
-    inline ObjectModel* model() const { return m_model; }
+    inline void setModel(ObjectModel *model) { m_model = model; }
+    inline ObjectModel *model() const { return m_model; }
 
     Str displayModelData();
-    void modifyModelData(Str& data);
+    void modifyModelData(Str &data);
 
-    ObjectType* getRawModelData();
+    ObjectType *getRawModelData();
 
 private:
-    ObjectModel* m_model;
+    ObjectModel *m_model;
 };
 
 #endif // OBJECTVIEW_H
-
diff --git a/sources/shiboken6/tests/libsample/oddbool.cpp b/sources/shiboken6/tests/libsample/oddbool.cpp
index 06a61f1c2..bc1ee833f 100644
--- a/sources/shiboken6/tests/libsample/oddbool.cpp
+++ b/sources/shiboken6/tests/libsample/oddbool.cpp
@@ -7,7 +7,7 @@ ComparisonTester::ComparisonTester(int v) : m_value(v)
 {
 }
 
-ComparisonTester& ComparisonTester::operator=(int v)
+ComparisonTester &ComparisonTester::operator=(int v)
 {
     m_value = v;
     return *this;
diff --git a/sources/shiboken6/tests/libsample/oddbool.h b/sources/shiboken6/tests/libsample/oddbool.h
index a64a05eb3..dd2d32604 100644
--- a/sources/shiboken6/tests/libsample/oddbool.h
+++ b/sources/shiboken6/tests/libsample/oddbool.h
@@ -16,7 +16,7 @@ class OddBool
 {
 
 public:
-    inline explicit OddBool(bool b) : m_value(b) {}
+    inline explicit OddBool(bool b) noexcept : m_value(b) {}
     bool value() const { return m_value; }
 
     inline OddBool operator!() const { return OddBool(!m_value); }
@@ -35,9 +35,11 @@ inline bool operator!=(OddBool b1, OddBool b2) { return (!b1).value() != (!b2).v
 class OddBoolUser
 {
 public:
-    OddBoolUser() : m_oddbool(OddBool(false)) {}
-    OddBoolUser(const OddBool& oddBool) : m_oddbool(oddBool) {}
-    virtual ~OddBoolUser() {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(OddBoolUser)
+
+    OddBoolUser() noexcept : m_oddbool(OddBool(false)) {}
+    OddBoolUser(const OddBool &oddBool) : m_oddbool(oddBool) {}
+    virtual ~OddBoolUser() = default;
 
     inline OddBool oddBool() { return m_oddbool; }
     inline void setOddBool(OddBool oddBool) { m_oddbool = oddBool; }
@@ -52,7 +54,7 @@ public:
         return invertedOddBool();
     }
 
-    static inline OddBool getOddBool(const OddBoolUser& oddBoolUser)
+    static inline OddBool getOddBool(const OddBoolUser &oddBoolUser)
     {
         return oddBoolUser.m_oddbool;
     }
diff --git a/sources/shiboken6/tests/libsample/onlycopy.cpp b/sources/shiboken6/tests/libsample/onlycopy.cpp
index 6fa4ad064..981ea88a4 100644
--- a/sources/shiboken6/tests/libsample/onlycopy.cpp
+++ b/sources/shiboken6/tests/libsample/onlycopy.cpp
@@ -11,45 +11,23 @@ public:
     int value;
 };
 
-OnlyCopy::OnlyCopy(int value) : d(new OnlyCopyPrivate(value))
+OnlyCopy::OnlyCopy(int value) : d(std::make_shared<OnlyCopyPrivate>(value))
 {
-
 }
 
-OnlyCopy::OnlyCopy(OnlyCopyPrivate *dIn) : d(dIn)
-{
-}
-
-OnlyCopy::~OnlyCopy()
-{
-    delete d;
-}
-
-OnlyCopy::OnlyCopy(const OnlyCopy& other) : d(new OnlyCopyPrivate(other.value()))
-{
-}
-
-OnlyCopy&
-OnlyCopy::operator=(const OnlyCopy& other)
-{
-    d->value = other.d->value;
-    return *this;
-}
+OnlyCopy::~OnlyCopy() = default;
 
 int OnlyCopy::value() const
 {
     return d->value;
 }
 
-OnlyCopy
-FriendOfOnlyCopy::createOnlyCopy(int value)
+OnlyCopy FriendOfOnlyCopy::createOnlyCopy(int value)
 {
-
     return OnlyCopy(value);
 }
 
-std::list<OnlyCopy>
-FriendOfOnlyCopy::createListOfOnlyCopy(int quantity)
+std::list<OnlyCopy> FriendOfOnlyCopy::createListOfOnlyCopy(int quantity)
 {
     std::list<OnlyCopy> list;
     for (int i = 0; i < quantity; ++i)
diff --git a/sources/shiboken6/tests/libsample/onlycopy.h b/sources/shiboken6/tests/libsample/onlycopy.h
index e7c411a18..7dc3e0069 100644
--- a/sources/shiboken6/tests/libsample/onlycopy.h
+++ b/sources/shiboken6/tests/libsample/onlycopy.h
@@ -5,7 +5,9 @@
 #define ONLYCOPYCLASS_H
 
 #include "libsamplemacros.h"
+
 #include <list>
+#include <memory>
 
 // These classes simulate a situation found in QWebEngineHistoryItem.
 
@@ -14,18 +16,20 @@ class OnlyCopyPrivate;
 class LIBSAMPLE_API OnlyCopy
 {
 public:
-    OnlyCopy(const OnlyCopy& other);
-    OnlyCopy& operator=(const OnlyCopy& other);
+    LIBMINIMAL_DEFAULT_COPY_MOVE(OnlyCopy)
+
     ~OnlyCopy();
 
     int value() const;
     static int getValue(OnlyCopy onlyCopy) { return onlyCopy.value(); }
-    static int getValueFromReference(const OnlyCopy& onlyCopy) { return onlyCopy.value(); }
+    static int getValueFromReference(const OnlyCopy &onlyCopy) { return onlyCopy.value(); }
+
 private:
-    OnlyCopyPrivate *d;
-    explicit OnlyCopy(int value);
-    explicit OnlyCopy(OnlyCopyPrivate *d); // rejected due to unknown OnlyCopyPrivate
     friend class FriendOfOnlyCopy;
+
+    explicit OnlyCopy(int value);
+
+    std::shared_ptr<OnlyCopyPrivate> d;
 };
 
 class LIBSAMPLE_API FriendOfOnlyCopy
@@ -35,4 +39,4 @@ public:
     static std::list<OnlyCopy> createListOfOnlyCopy(int quantity);
 };
 
-#endif
+#endif // ONLYCOPYCLASS_H
diff --git a/sources/shiboken6/tests/libsample/overload.cpp b/sources/shiboken6/tests/libsample/overload.cpp
index d533b4014..34da28e03 100644
--- a/sources/shiboken6/tests/libsample/overload.cpp
+++ b/sources/shiboken6/tests/libsample/overload.cpp
@@ -35,11 +35,13 @@ int Overload::differentReturnTypes(ParamEnum, int val)
 
 int Overload::intOverloads(const Point &, double)
 {
-    return 1; }
+    return 1;
+}
 
 int Overload::intOverloads(int, int)
 {
-    return 2; }
+    return 2;
+}
 
 int Overload::intOverloads(int, int, double)
 {
diff --git a/sources/shiboken6/tests/libsample/overload.h b/sources/shiboken6/tests/libsample/overload.h
index 91de8a963..b640bf7c7 100644
--- a/sources/shiboken6/tests/libsample/overload.h
+++ b/sources/shiboken6/tests/libsample/overload.h
@@ -17,6 +17,8 @@
 class LIBSAMPLE_API Overload
 {
 public:
+    LIBMINIMAL_DISABLE_COPY_MOVE(Overload)
+
     enum FunctionEnum {
         Function0,
         Function1,
@@ -32,13 +34,13 @@ public:
         Param1
     };
 
-    Overload() {}
-    virtual ~Overload() {}
+    Overload() noexcept = default;
+    virtual ~Overload() = default;
 
     FunctionEnum overloaded();
-    FunctionEnum overloaded(Size* size);
-    FunctionEnum overloaded(Point* point, ParamEnum param);
-    FunctionEnum overloaded(const Point& point);
+    FunctionEnum overloaded(Size *size);
+    FunctionEnum overloaded(Point *point, ParamEnum param);
+    FunctionEnum overloaded(const Point &point);
 
     void differentReturnTypes(ParamEnum param = Param0);
     int differentReturnTypes(ParamEnum param, int val);
@@ -51,7 +53,7 @@ public:
     FunctionEnum intDoubleOverloads(double a0, double a1) const;
 
     void singleOverload(Point *x);
-    Point* singleOverload() {return new Point();}
+    Point *singleOverload() { return new Point(); }
 
     // Similar to QImage::trueMatrix(QMatrix,int,int) and QImage::trueMatrix(QTransform,int,int)
     FunctionEnum wrapperIntIntOverloads(const Point &arg0, int arg1, int arg2);
@@ -60,7 +62,7 @@ public:
     // Similar to QImage constructor
     FunctionEnum strBufferOverloads(const Str &arg0, const char *arg1 = nullptr,
                                     bool arg2 = true);
-    FunctionEnum strBufferOverloads(unsigned char* arg0, int arg1);
+    FunctionEnum strBufferOverloads(unsigned char *arg0, int arg1);
     FunctionEnum strBufferOverloads() { return Function2; }
 
     // Similar to QPainter::drawText(...)
@@ -95,7 +97,7 @@ public:
     FunctionEnum acceptSequence(const Str &a0, ParamEnum a1 = Param0);
     FunctionEnum acceptSequence(const Size &a0);
     // The type must be changed to PySequence.
-    FunctionEnum acceptSequence(const char* const a0[]);
+    FunctionEnum acceptSequence(const char *const a0[]);
     FunctionEnum acceptSequence(void *a0);
 };
 
diff --git a/sources/shiboken6/tests/libsample/overloadsort.h b/sources/shiboken6/tests/libsample/overloadsort.h
index 473828da9..ee269cc21 100644
--- a/sources/shiboken6/tests/libsample/overloadsort.h
+++ b/sources/shiboken6/tests/libsample/overloadsort.h
@@ -11,13 +11,13 @@
 class ImplicitTarget
 {
 public:
-    ImplicitTarget(){}
+    ImplicitTarget() = default;
 };
 
 class ImplicitBase
 {
 public:
-    ImplicitBase(){}
+    ImplicitBase() = default;
     ImplicitBase(const ImplicitTarget &b);
 };
 
@@ -39,9 +39,9 @@ public:
 
     const char *overloadDeep(int x, ImplicitBase &y);
 
-    inline const char* pyObjOverload(int, int) { return "int,int"; }
-    inline const char* pyObjOverload(unsigned char*, int) { return "PyObject,int"; }
-
+    inline const char *pyObjOverload(int, int) { return "int,int"; }
+    inline const char *pyObjOverload(unsigned char *, int)
+    { return "PyObject,int"; }
 };
 
 class LIBSAMPLE_API CustomOverloadSequence
@@ -52,4 +52,3 @@ public:
 };
 
 #endif // OVERLOADSORT_H
-
diff --git a/sources/shiboken6/tests/libsample/pairuser.cpp b/sources/shiboken6/tests/libsample/pairuser.cpp
index f1f182c5a..5b7eb4d8c 100644
--- a/sources/shiboken6/tests/libsample/pairuser.cpp
+++ b/sources/shiboken6/tests/libsample/pairuser.cpp
@@ -1,32 +1,24 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
 #include "pairuser.h"
 
-using namespace std;
-
-std::pair<int, int>
-PairUser::callCreatePair()
+std::pair<int, int> PairUser::callCreatePair()
 {
     return createPair();
 }
 
-std::pair<int, int>
-PairUser::createPair()
+std::pair<int, int> PairUser::createPair()
 {
-    return std::pair<int, int>(10, 20);
+    return {10, 20};
 }
 
-std::pair<Complex, Complex>
-PairUser::createComplexPair(Complex cpx0, Complex cpx1)
+std::pair<Complex, Complex> PairUser::createComplexPair(Complex cpx0, Complex cpx1)
 {
-    return std::pair<Complex, Complex>(cpx0, cpx1);
+    return {cpx0, cpx1};
 }
 
-double
-PairUser::sumPair(std::pair<int, double> pair)
+double PairUser::sumPair(std::pair<int, double> pair)
 {
     return ((double) pair.first) + pair.second;
 }
-
diff --git a/sources/shiboken6/tests/libsample/pairuser.h b/sources/shiboken6/tests/libsample/pairuser.h
index 313651c06..ee51d818e 100644
--- a/sources/shiboken6/tests/libsample/pairuser.h
+++ b/sources/shiboken6/tests/libsample/pairuser.h
@@ -4,16 +4,18 @@
 #ifndef PAIRUSER_H
 #define PAIRUSER_H
 
-#include <utility>
+#include "libsamplemacros.h"
 #include "complex.h"
 
-#include "libsamplemacros.h"
+#include <utility>
 
 class LIBSAMPLE_API PairUser
 {
 public:
-    PairUser() {}
-    virtual ~PairUser() {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(PairUser)
+
+    PairUser() noexcept = default;
+    virtual ~PairUser() = default;
 
     virtual std::pair<int, int> createPair();
     std::pair<int, int> callCreatePair();
@@ -26,5 +28,5 @@ public:
 private:
     std::pair<int, int> m_pair;
 };
-#endif // PAIRUSER_H
 
+#endif // PAIRUSER_H
diff --git a/sources/shiboken6/tests/libsample/pen.cpp b/sources/shiboken6/tests/libsample/pen.cpp
index 8e216323f..76473a264 100644
--- a/sources/shiboken6/tests/libsample/pen.cpp
+++ b/sources/shiboken6/tests/libsample/pen.cpp
@@ -45,9 +45,7 @@ void Brush::setColor(const Color &newColor)
     m_color = newColor;
 }
 
-Pen::Pen() : m_ctor(EmptyCtor)
-{
-}
+Pen::Pen() = default;
 
 Pen::Pen(SampleNamespace::Option) : m_ctor(EnumCtor)
 {
@@ -61,9 +59,9 @@ Pen::Pen(const Pen &) : m_ctor(CopyCtor)
 {
 }
 
-Pen::Pen(Pen &&) = default;
-Pen &Pen::operator=(const Pen& pen) = default;
-Pen &Pen::operator=(Pen &&) = default;
+Pen::Pen(Pen &&) noexcept = default;
+Pen &Pen::operator=(const Pen &pen) = default;
+Pen &Pen::operator=(Pen &&) noexcept = default;
 
 int Pen::ctorType()
 {
diff --git a/sources/shiboken6/tests/libsample/pen.h b/sources/shiboken6/tests/libsample/pen.h
index 114810d25..6f528f0f9 100644
--- a/sources/shiboken6/tests/libsample/pen.h
+++ b/sources/shiboken6/tests/libsample/pen.h
@@ -15,6 +15,7 @@ public:
     Color(unsigned int arg);
 
     bool isNull() const;
+
 private:
     bool m_null = true;
 };
@@ -48,11 +49,12 @@ public:
 
     Pen();
     Pen(SampleNamespace::Option option);
-    Pen(const Color& color);
+    Pen(const Color &color);
     Pen(const Pen &pen);
-    Pen(Pen &&);
+    Pen(Pen &&) noexcept;
     Pen &operator=(const Pen &pen);
-    Pen &operator=(Pen &&);
+    Pen &operator=(Pen &&) noexcept;
+    ~Pen() = default;
 
     // PYSIDE-1325, default initializer
     void drawLine(int x1, int y1, int x2, int y2, RenderHints renderHints = {});
@@ -63,7 +65,7 @@ public:
     void setRenderHints(RenderHints h);
 
 private:
-    int m_ctor;
+    int m_ctor = EmptyCtor;
     RenderHints m_renderHints = None;
 };
 
diff --git a/sources/shiboken6/tests/libsample/photon.cpp b/sources/shiboken6/tests/libsample/photon.cpp
index f98a7c891..2a7f20e33 100644
--- a/sources/shiboken6/tests/libsample/photon.cpp
+++ b/sources/shiboken6/tests/libsample/photon.cpp
@@ -5,21 +5,27 @@
 
 namespace Photon
 {
+
 const ClassType Base::staticType;
-int callCalculateForValueDuplicatorPointer(ValueDuplicator* value)
+
+int callCalculateForValueDuplicatorPointer(ValueDuplicator *value)
 {
     return value->calculate();
 }
-int callCalculateForValueDuplicatorReference(ValueDuplicator& value)
+
+int callCalculateForValueDuplicatorReference(ValueDuplicator &value)
 {
     return value.calculate();
 }
-int countValueIdentities(const std::list<ValueIdentity>& values)
+
+int countValueIdentities(const std::list<ValueIdentity> &values)
 {
     return values.size();
 }
-int countValueDuplicators(const std::list<TemplateBase<DuplicatorType> >& values)
+
+int countValueDuplicators(const std::list<TemplateBase<DuplicatorType> > &values)
 {
     return values.size();
 }
+
 } // namespace Photon
diff --git a/sources/shiboken6/tests/libsample/photon.h b/sources/shiboken6/tests/libsample/photon.h
index 2fbf87d25..2debe47d1 100644
--- a/sources/shiboken6/tests/libsample/photon.h
+++ b/sources/shiboken6/tests/libsample/photon.h
@@ -4,9 +4,10 @@
 #ifndef PHOTON_H
 #define PHOTON_H
 
-#include <list>
 #include "libsamplemacros.h"
 
+#include <list>
+
 // This namespace and classes simulate
 // situations found in Qt's phonon module.
 
@@ -22,8 +23,11 @@ enum ClassType {
 class LIBSAMPLE_API Base
 {
 public:
-    explicit Base(int value) : m_value(value) {}
-    virtual ~Base() {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(Base)
+
+    explicit Base(int value) noexcept : m_value(value) {}
+    virtual ~Base() = default;
+
     inline void setValue(int value) { m_value = value; }
     inline int value() const { return m_value; }
 
@@ -42,12 +46,14 @@ class LIBSAMPLE_API TemplateBase : public Base
 {
 public:
     explicit TemplateBase(int value) : Base(value) {}
-    inline int multiplicator() const { return (int)CLASS_TYPE; }
-    inline int calculate() const { return m_value * ((int)CLASS_TYPE); }
+    inline int multiplicator() const { return int(CLASS_TYPE); }
+    inline int calculate() const { return m_value * (int(CLASS_TYPE)); }
     static inline ClassType classType() { return CLASS_TYPE; }
 
-    inline int sumValueUsingPointer(TemplateBase<CLASS_TYPE>* other) const { return m_value + other->m_value; }
-    inline int sumValueUsingReference(TemplateBase<CLASS_TYPE>& other) const { return m_value + other.m_value; }
+    inline int sumValueUsingPointer(TemplateBase<CLASS_TYPE> *other) const
+    { return m_value + other->m_value; }
+    inline int sumValueUsingReference(TemplateBase<CLASS_TYPE> &other) const
+    { return m_value + other.m_value; }
 
     inline std::list<TemplateBase<CLASS_TYPE> > getListOfThisTemplateBase()
     {
@@ -57,7 +63,8 @@ public:
         return objs;
     }
 
-    static inline TemplateBase<CLASS_TYPE>* passPointerThrough(TemplateBase<CLASS_TYPE>* obj) { return obj; }
+    static inline TemplateBase<CLASS_TYPE> *passPointerThrough(TemplateBase<CLASS_TYPE> *obj)
+    { return obj; }
 
     ClassType type() const override { return CLASS_TYPE; }
     static const ClassType staticType = CLASS_TYPE;
@@ -71,43 +78,31 @@ template class LIBSAMPLE_API TemplateBase<DuplicatorType>;
 using ValueIdentity = TemplateBase<IdentityType>;
 using ValueDuplicator = TemplateBase<DuplicatorType>;
 
-LIBSAMPLE_API int callCalculateForValueDuplicatorPointer(ValueDuplicator* value);
-LIBSAMPLE_API int callCalculateForValueDuplicatorReference(ValueDuplicator& value);
-LIBSAMPLE_API int countValueIdentities(const std::list<ValueIdentity>& values);
-LIBSAMPLE_API int countValueDuplicators(const std::list<TemplateBase<DuplicatorType> >& values);
-
-// This simulates an internal error (SEGV) caused by 'noexcept' in
-// boost::intrusive_ptr before support for 'noexcept' was added. The ENTIRE
-// code below is needed to trigger the exception; it isn't seen with just a
-// 'noexcept' following a declaration.
-//
-// NOTE: For reasons that should be fairly obvious, this test unfortunately can
-//       only be "run" when building in C++11 mode.
-#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900)
-#  define PHOTON_NOEXCEPT noexcept
-#else
-#  define PHOTON_NOEXCEPT
-#endif
+LIBSAMPLE_API int callCalculateForValueDuplicatorPointer(ValueDuplicator *value);
+LIBSAMPLE_API int callCalculateForValueDuplicatorReference(ValueDuplicator &value);
+LIBSAMPLE_API int countValueIdentities(const std::list<ValueIdentity> &values);
+LIBSAMPLE_API int countValueDuplicators(const std::list<TemplateBase<DuplicatorType> > &values);
+
 class Pointer
 {
 public:
-    Pointer() PHOTON_NOEXCEPT : px(nullptr) {}
-    Pointer(int* p) : px(p) {}
+    Pointer() noexcept = default;
+    explicit Pointer(int *p) : px(p) {}
 
-    void reset() PHOTON_NOEXCEPT { Pointer().swap(*this); }
+    void reset() noexcept { Pointer().swap(*this); }
 
-    int* get() const PHOTON_NOEXCEPT { return px; }
-    int& operator*() const { return *px; }
+    int *get() const noexcept { return px; }
+    int &operator*() const { return *px; }
 
-    void swap(Pointer& rhs) PHOTON_NOEXCEPT
+    void swap(Pointer &rhs) noexcept
     {
-        int* tmp = px;
+        int *tmp = px;
         px = rhs.px;
         rhs.px = tmp;
     }
 
 private:
-    int* px;
+    int *px = nullptr;
 };
 
 } // namespace Photon
diff --git a/sources/shiboken6/tests/libsample/point.cpp b/sources/shiboken6/tests/libsample/point.cpp
index 397dea3e6..0a28e877f 100644
--- a/sources/shiboken6/tests/libsample/point.cpp
+++ b/sources/shiboken6/tests/libsample/point.cpp
@@ -1,21 +1,19 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
 #include "point.h"
 
-using namespace std;
+#include <iostream>
 
-Point::Point(int x, int y) : m_x(x), m_y(y)
+Point::Point(int x, int y) noexcept : m_x(x), m_y(y)
 {
 }
 
-Point::Point(double x, double y) : m_x(x), m_y(y)
+Point::Point(double x, double y) noexcept : m_x(x), m_y(y)
 {
 }
 
-void
-Point::midpoint(const Point& other, Point* midpoint) const
+void Point::midpoint(const Point &other, Point *midpoint) const
 {
     if (!midpoint)
         return;
@@ -23,108 +21,91 @@ Point::midpoint(const Point& other, Point* midpoint) const
     midpoint->setY((m_y + other.m_y) / 2.0);
 }
 
-Point*
-Point::copy() const
+Point *Point::copy() const
 {
-    Point* pt = new Point();
+    Point *pt = new Point();
     pt->m_x = m_x;
     pt->m_y = m_y;
     return pt;
 }
 
-void
-Point::show()
+void Point::show() const
 {
-    cout << "(x: " << m_x << ", y: " << m_y << ")";
+    std::cout << "(x: " << m_x << ", y: " << m_y << ")";
 }
 
-bool
-Point::operator==(const Point& other)
+bool Point::operator==(const Point &other) const
 {
     return m_x == other.m_x && m_y == other.m_y;
 }
 
-Point
-Point::operator+(const Point& other)
+Point Point::operator+(const Point &other)
 {
-    return Point(m_x + other.m_x, m_y + other.m_y);
+    return {m_x + other.m_x, m_y + other.m_y};
 }
 
-Point
-Point::operator-(const Point& other)
+Point Point::operator-(const Point &other)
 {
-    return Point(m_x - other.m_x, m_y - other.m_y);
+    return {m_x - other.m_x, m_y - other.m_y};
 }
 
-Point&
-Point::operator+=(Point &other)
+Point &Point::operator+=(Point &other)
 {
     m_x += other.m_x;
     m_y += other.m_y;
     return *this;
 }
 
-Point&
-Point::operator-=(Point &other)
+Point &Point::operator-=(Point &other)
 {
     m_x -= other.m_x;
     m_y -= other.m_y;
     return *this;
 }
 
-Point
-operator*(const Point& pt, double mult)
+Point operator*(const Point &pt, double mult)
 {
     return Point(pt.m_x * mult, pt.m_y * mult);
 }
 
-Point
-operator*(const Point& pt, int mult)
+Point operator*(const Point &pt, int mult)
 {
-    return Point(((int) pt.m_x) * mult, ((int) pt.m_y) * mult);
+    return {int(pt.m_x) * mult, int(pt.m_y) * mult};
 }
 
-Point
-operator*(double mult, const Point& pt)
+Point operator*(double mult, const Point &pt)
 {
-    return Point(pt.m_x * mult, pt.m_y * mult);
+    return {pt.m_x * mult, pt.m_y * mult};
 }
 
-Point
-operator*(int mult, const Point& pt)
+Point operator*(int mult, const Point &pt)
 {
-    return Point(((int) pt.m_x) * mult, ((int) pt.m_y) * mult);
+    return {int(pt.m_x) * mult, int(pt.m_y) * mult};
 }
 
-Point
-operator-(const Point& pt)
+Point operator-(const Point &pt)
 {
-    return Point(-pt.m_x, -pt.m_y);
+    return {-pt.m_x, -pt.m_y};
 }
 
-bool
-operator!(const Point& pt)
+bool operator!(const Point &pt)
 {
-    return (pt.m_x == 0.0 && pt.m_y == 0.0);
+    return pt.m_x == 0.0 && pt.m_y == 0.0;
 }
 
-Point
-Point::operator/(int operand)
+Point Point::operator/(int operand)
 {
-    return Point(m_x/operand, m_y/operand);
+    return {m_x/operand, m_y/operand};
 }
 
-Complex
-transmutePointIntoComplex(const Point& point)
+Complex transmutePointIntoComplex(const Point &point)
 {
     Complex cpx(point.x(), point.y());
     return cpx;
 }
 
-Point
-transmuteComplexIntoPoint(const Complex& cpx)
+Point transmuteComplexIntoPoint(const Complex &cpx)
 {
     Point pt(cpx.real(), cpx.imag());
     return pt;
 }
-
diff --git a/sources/shiboken6/tests/libsample/point.h b/sources/shiboken6/tests/libsample/point.h
index 717658b09..7e5d128ab 100644
--- a/sources/shiboken6/tests/libsample/point.h
+++ b/sources/shiboken6/tests/libsample/point.h
@@ -4,17 +4,19 @@
 #ifndef POINT_H
 #define POINT_H
 
+#include "libsamplemacros.h"
 #include "complex.h"
-#include <utility>
 
-#include "libsamplemacros.h"
+#include <utility>
 
 class LIBSAMPLE_API Point
 {
 public:
-    Point(int x = 0, int y = 0);
-    Point(double x, double y);
-    ~Point() {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(Point)
+
+    Point(int x = 0, int y = 0) noexcept;
+    Point(double x, double y) noexcept;
+    ~Point() = default;
 
     inline double x() const { return m_x; }
     inline double y() const { return m_y; }
@@ -27,48 +29,48 @@ public:
     // This method could simply return the midpoint,
     // but the interesting part of the test is to set the
     // result in the pointer argument.
-    void midpoint(const Point& other, Point* midpoint) const;
+    void midpoint(const Point &other, Point *midpoint) const;
 
-    Point* copy() const;
+    Point *copy() const;
 
-    inline const Point& getConstReferenceToSelf() const { return *this; }
-    inline const Point* getSelf() const { return this; }
+    inline const Point &getConstReferenceToSelf() const { return *this; }
+    inline const Point *getSelf() const { return this; }
 
     // The != operator is not implemented for the purpose of testing
     // for the absense of the __ne__ method in the Python binding.
-    bool operator==(const Point& other);
+    bool operator==(const Point &other) const;
 
-    Point operator+(const Point& other);
-    Point operator-(const Point& other);
+    Point operator+(const Point &other);
+    Point operator-(const Point &other);
     Point operator/(int operand);
 
-    friend LIBSAMPLE_API Point operator*(const Point& pt, double mult);
-    friend LIBSAMPLE_API Point operator*(const Point& pt, int mult);
-    friend LIBSAMPLE_API Point operator*(double mult, const Point& pt);
-    friend LIBSAMPLE_API Point operator*(int mult, const Point& pt);
-    friend LIBSAMPLE_API Point operator-(const Point& pt);
-    friend LIBSAMPLE_API bool operator!(const Point& pt);
+    friend LIBSAMPLE_API Point operator*(const Point &pt, double mult);
+    friend LIBSAMPLE_API Point operator*(const Point &pt, int mult);
+    friend LIBSAMPLE_API Point operator*(double mult, const Point &pt);
+    friend LIBSAMPLE_API Point operator*(int mult, const Point &pt);
+    friend LIBSAMPLE_API Point operator-(const Point &pt);
+    friend LIBSAMPLE_API bool operator!(const Point &pt);
 
-    Point& operator+=(Point &other);
-    Point& operator-=(Point &other);
+    Point &operator+=(Point &other);
+    Point &operator-=(Point &other);
 
-    void show();
+    void show() const;
 
 private:
     double m_x;
     double m_y;
 };
 
-LIBSAMPLE_API Point operator*(const Point& pt, double mult);
-LIBSAMPLE_API Point operator*(const Point& pt, int mult);
-LIBSAMPLE_API Point operator*(double mult, const Point& pt);
-LIBSAMPLE_API Point operator*(int mult, const Point& pt);
-LIBSAMPLE_API Point operator-(const Point& pt);
-LIBSAMPLE_API bool operator!(const Point& pt);
+LIBSAMPLE_API Point operator*(const Point &pt, double mult);
+LIBSAMPLE_API Point operator*(const Point &pt, int mult);
+LIBSAMPLE_API Point operator*(double mult, const Point &pt);
+LIBSAMPLE_API Point operator*(int mult, const Point &pt);
+LIBSAMPLE_API Point operator-(const Point &pt);
+LIBSAMPLE_API bool operator!(const Point &pt);
 
-LIBSAMPLE_API Complex transmutePointIntoComplex(const Point& point);
-LIBSAMPLE_API Point transmuteComplexIntoPoint(const Complex& cpx);
+LIBSAMPLE_API Complex transmutePointIntoComplex(const Point &point);
+LIBSAMPLE_API Point transmuteComplexIntoPoint(const Complex &cpx);
 
-LIBSAMPLE_API Point operator*(const Point& pt, double multiplier);
+LIBSAMPLE_API Point operator*(const Point &pt, double multiplier);
 
 #endif // POINT_H
diff --git a/sources/shiboken6/tests/libsample/pointerholder.h b/sources/shiboken6/tests/libsample/pointerholder.h
index 36ce32205..26f1cf0a6 100644
--- a/sources/shiboken6/tests/libsample/pointerholder.h
+++ b/sources/shiboken6/tests/libsample/pointerholder.h
@@ -9,12 +9,15 @@
 class PointerHolder
 {
 public:
-    explicit PointerHolder(void* ptr) : m_pointer(ptr) {}
-    ~PointerHolder() {}
-    inline void* pointer() const { return m_pointer; }
+    LIBMINIMAL_DEFAULT_COPY_MOVE(PointerHolder)
+
+    explicit PointerHolder(void *ptr) : m_pointer(ptr) {}
+    ~PointerHolder() = default;
+
+    inline void *pointer() const { return m_pointer; }
+
 private:
-    void* m_pointer;
+    void *m_pointer;
 };
 
 #endif // POINTERHOLDER_H
-
diff --git a/sources/shiboken6/tests/libsample/pointf.cpp b/sources/shiboken6/tests/libsample/pointf.cpp
index f68dd0f41..736a5c6b5 100644
--- a/sources/shiboken6/tests/libsample/pointf.cpp
+++ b/sources/shiboken6/tests/libsample/pointf.cpp
@@ -1,21 +1,19 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
 #include "pointf.h"
 
-using namespace std;
+#include <iostream>
 
-PointF::PointF(const Point& point) : m_x(point.x()), m_y(point.y())
+PointF::PointF(const Point &point) noexcept : m_x(point.x()), m_y(point.y())
 {
 }
 
-PointF::PointF(double x, double y) : m_x(x), m_y(y)
+PointF::PointF(double x, double y) noexcept : m_x(x), m_y(y)
 {
 }
 
-void
-PointF::midpoint(const PointF& other, PointF* midpoint) const
+void PointF::midpoint(const PointF &other, PointF *midpoint) const
 {
     if (!midpoint)
         return;
@@ -23,79 +21,66 @@ PointF::midpoint(const PointF& other, PointF* midpoint) const
     midpoint->setY((m_y + other.m_y) / 2.0);
 }
 
-void
-PointF::show()
+void PointF::show() const
 {
-    cout << "(x: " << m_x << ", y: " << m_y << ")";
+    std::cout << "(x: " << m_x << ", y: " << m_y << ")";
 }
 
-bool
-PointF::operator==(const PointF& other)
+bool PointF::operator==(const PointF &other) const
 {
     return m_x == other.m_x && m_y == other.m_y;
 }
 
-PointF
-PointF::operator+(const PointF& other)
+PointF PointF::operator+(const PointF &other)
 {
-    return PointF(m_x + other.m_x, m_y + other.m_y);
+    return {m_x + other.m_x, m_y + other.m_y};
 }
 
-PointF
-PointF::operator-(const PointF& other)
+PointF PointF::operator-(const PointF &other)
 {
-    return PointF(m_x - other.m_x, m_y - other.m_y);
+    return {m_x - other.m_x, m_y - other.m_y};
 }
 
-PointF&
-PointF::operator+=(PointF &other)
+PointF &PointF::operator+=(PointF &other)
 {
     m_x += other.m_x;
     m_y += other.m_y;
     return *this;
 }
 
-PointF&
-PointF::operator-=(PointF &other)
+PointF &PointF::operator-=(PointF &other)
 {
     m_x -= other.m_x;
     m_y -= other.m_y;
     return *this;
 }
 
-PointF
-operator*(const PointF& pt, double mult)
+PointF operator*(const PointF &pt, double mult)
 {
-    return PointF(pt.m_x * mult, pt.m_y * mult);
+    return {pt.m_x * mult, pt.m_y * mult};
 }
 
-PointF
-operator*(const PointF& pt, int mult)
+PointF operator*(const PointF &pt, int mult)
 {
-    return PointF(((int) pt.m_x) * mult, ((int) pt.m_y) * mult);
+    return PointF(int(pt.m_x) * mult, int(pt.m_y) * mult);
 }
 
-PointF
-operator*(double mult, const PointF& pt)
+PointF operator*(double mult, const PointF &pt)
 {
-    return PointF(pt.m_x * mult, pt.m_y * mult);
+    return {pt.m_x * mult, pt.m_y * mult};
 }
 
-PointF
-operator*(int mult, const PointF& pt)
+PointF operator*(int mult, const PointF &pt)
 {
-    return PointF(((int) pt.m_x) * mult, ((int) pt.m_y) * mult);
+    return PointF(int(pt.m_x) * mult, int(pt.m_y) * mult);
 }
 
-PointF
-operator-(const PointF& pt)
+PointF operator-(const PointF &pt)
 {
-    return PointF(-pt.m_x, -pt.m_y);
+    return {-pt.m_x, -pt.m_y};
 }
 
-bool
-operator!(const PointF& pt)
+bool operator!(const PointF &pt)
 {
-    return (pt.m_x == 0.0 && pt.m_y == 0.0);
+    return pt.m_x == 0.0 && pt.m_y == 0.0;
 }
-
diff --git a/sources/shiboken6/tests/libsample/pointf.h b/sources/shiboken6/tests/libsample/pointf.h
index 86c8c9d2a..49e009467 100644
--- a/sources/shiboken6/tests/libsample/pointf.h
+++ b/sources/shiboken6/tests/libsample/pointf.h
@@ -4,17 +4,19 @@
 #ifndef POINTF_H
 #define POINTF_H
 
+#include "libsamplemacros.h"
 #include "point.h"
-#include <utility>
 
-#include "libsamplemacros.h"
+#include <utility>
 
 class LIBSAMPLE_API PointF
 {
 public:
-    PointF(const Point& point);
-    PointF(double x = 0.0, double y = 0.0);
-    ~PointF() {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(PointF)
+
+    PointF(const Point &point) noexcept;
+    PointF(double x = 0.0, double y = 0.0) noexcept;
+    ~PointF() noexcept = default;
 
     inline double x() const { return m_x; }
     inline double y() const { return m_y; }
@@ -25,39 +27,39 @@ public:
     // This method could simply return the midpoint,
     // but the interesting part of the test is to set the
     // result in the pointer argument.
-    void midpoint(const PointF& other, PointF* midpoint) const;
+    void midpoint(const PointF &other, PointF *midpoint) const;
 
     // The != operator is not implemented for the purpose of testing
     // for the absence of the __ne__ method in the Python binding.
-    bool operator==(const PointF& other);
+    bool operator==(const PointF &other) const;
 
-    PointF operator+(const PointF& other);
-    PointF operator-(const PointF& other);
+    PointF operator+(const PointF &other);
+    PointF operator-(const PointF &other);
 
-    friend LIBSAMPLE_API PointF operator*(const PointF& pt, double mult);
-    friend LIBSAMPLE_API PointF operator*(const PointF& pt, int mult);
-    friend LIBSAMPLE_API PointF operator*(double mult, const PointF& pt);
-    friend LIBSAMPLE_API PointF operator*(int mult, const PointF& pt);
-    friend LIBSAMPLE_API PointF operator-(const PointF& pt);
-    friend LIBSAMPLE_API bool operator!(const PointF& pt);
+    friend LIBSAMPLE_API PointF operator*(const PointF &pt, double mult);
+    friend LIBSAMPLE_API PointF operator*(const PointF &pt, int mult);
+    friend LIBSAMPLE_API PointF operator*(double mult, const PointF &pt);
+    friend LIBSAMPLE_API PointF operator*(int mult, const PointF &pt);
+    friend LIBSAMPLE_API PointF operator-(const PointF &pt);
+    friend LIBSAMPLE_API bool operator!(const PointF &pt);
 
-    PointF& operator+=(PointF &other);
-    PointF& operator-=(PointF &other);
+    PointF &operator+=(PointF &other);
+    PointF &operator-=(PointF &other);
 
-    void show();
+    void show() const;
 
 private:
     double m_x;
     double m_y;
 };
 
-LIBSAMPLE_API PointF operator*(const PointF& pt, double mult);
-LIBSAMPLE_API PointF operator*(const PointF& pt, int mult);
-LIBSAMPLE_API PointF operator*(double mult, const PointF& pt);
-LIBSAMPLE_API PointF operator*(int mult, const PointF& pt);
-LIBSAMPLE_API PointF operator-(const PointF& pt);
-LIBSAMPLE_API bool operator!(const PointF& pt);
+LIBSAMPLE_API PointF operator*(const PointF &pt, double mult);
+LIBSAMPLE_API PointF operator*(const PointF &pt, int mult);
+LIBSAMPLE_API PointF operator*(double mult, const PointF &pt);
+LIBSAMPLE_API PointF operator*(int mult, const PointF &pt);
+LIBSAMPLE_API PointF operator-(const PointF &pt);
+LIBSAMPLE_API bool operator!(const PointF &pt);
 
-LIBSAMPLE_API PointF operator*(const PointF& pt, double multiplier);
+LIBSAMPLE_API PointF operator*(const PointF &pt, double multiplier);
 
 #endif // POINTF_H
diff --git a/sources/shiboken6/tests/libsample/polygon.cpp b/sources/shiboken6/tests/libsample/polygon.cpp
index 617ac4f9f..6af597192 100644
--- a/sources/shiboken6/tests/libsample/polygon.cpp
+++ b/sources/shiboken6/tests/libsample/polygon.cpp
@@ -1,34 +1,26 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
 #include "polygon.h"
 
-using namespace std;
-
-Polygon::Polygon(double x, double y)
+Polygon::Polygon(double x, double y) : m_points({Point(x, y)})
 {
-    m_points.push_back(Point(x, y));
 }
 
-Polygon::Polygon(Point point)
+Polygon::Polygon(Point point) : m_points({point})
 {
-    m_points.push_back(point);
 }
 
-Polygon::Polygon(PointList points)
+Polygon::Polygon(PointList points) : m_points(points)
 {
-    m_points = points;
 }
 
-void
-Polygon::addPoint(Point point)
+void Polygon::addPoint(Point point)
 {
     m_points.push_back(point);
 }
 
-Polygon
-Polygon::doublePolygonScale(Polygon polygon)
+Polygon Polygon::doublePolygonScale(Polygon polygon)
 {
     Polygon result;
     for (const auto &point : polygon.points())
@@ -36,15 +28,12 @@ Polygon::doublePolygonScale(Polygon polygon)
     return result;
 }
 
-void
-Polygon::stealOwnershipFromPython(Point* point)
+void Polygon::stealOwnershipFromPython(Point *point)
 {
     delete point;
 }
 
-void
-Polygon::stealOwnershipFromPython(Polygon* polygon)
+void Polygon::stealOwnershipFromPython(Polygon *polygon)
 {
     delete polygon;
 }
-
diff --git a/sources/shiboken6/tests/libsample/polygon.h b/sources/shiboken6/tests/libsample/polygon.h
index 9a7586d24..2424ddd51 100644
--- a/sources/shiboken6/tests/libsample/polygon.h
+++ b/sources/shiboken6/tests/libsample/polygon.h
@@ -4,38 +4,36 @@
 #ifndef POLYGON_H
 #define POLYGON_H
 
-#include <list>
+#include "libsamplemacros.h"
 #include "point.h"
 
-#include "libsamplemacros.h"
+#include <list>
 
-class LIBSAMPLE_API Polygon
+class LIBSAMPLE_API Polygon // should be moveable
 {
 public:
     using PointList = std::list<Point>;
 
-    Polygon() {}
+    Polygon() noexcept = default;
     Polygon(double x, double y);
     Polygon(Point point);
     Polygon(PointList points);
-    ~Polygon() {}
 
     void addPoint(Point point);
 
-    inline const PointList& points() const { return m_points; }
+    inline const PointList &points() const { return m_points; }
 
     // This method intentionally receives and returns copies of a Polygon object.
     static Polygon doublePolygonScale(Polygon polygon);
 
     // This method invalidates the argument to be used for Polygon(Point) implicit conversion.
-    static void stealOwnershipFromPython(Point* point);
+    static void stealOwnershipFromPython(Point *point);
 
     // This method invalidates the argument to be used in a call to doublePolygonScale(Polygon).
-    static void stealOwnershipFromPython(Polygon* polygon);
+    static void stealOwnershipFromPython(Polygon *polygon);
 
 private:
     PointList m_points;
 };
 
 #endif // POLYGON_H
-
diff --git a/sources/shiboken6/tests/libsample/privatector.h b/sources/shiboken6/tests/libsample/privatector.h
index 760fe4d13..3b38414f8 100644
--- a/sources/shiboken6/tests/libsample/privatector.h
+++ b/sources/shiboken6/tests/libsample/privatector.h
@@ -9,22 +9,22 @@
 class PrivateCtor
 {
 public:
-    inline static PrivateCtor* instance()
+    inline static PrivateCtor *instance()
     {
         static PrivateCtor self;
-        self.m_instanciations++;
+        self.m_instantiations++;
         return &self;
     }
 
     inline int instanceCalls()
     {
-        return m_instanciations;
+        return m_instantiations;
     }
 
 private:
-    int m_instanciations;
+    int m_instantiations = 0;
 
-    PrivateCtor() : m_instanciations(0) {}
+    PrivateCtor() = default;
 };
 
 class DeletedDefaultCtor
@@ -39,4 +39,4 @@ public:
     ~DeletedDefaultCtor() = default;
 };
 
-#endif
+#endif // PRIVATECTOR_H
diff --git a/sources/shiboken6/tests/libsample/privatedtor.h b/sources/shiboken6/tests/libsample/privatedtor.h
index 84591ccb2..05f18ea53 100644
--- a/sources/shiboken6/tests/libsample/privatedtor.h
+++ b/sources/shiboken6/tests/libsample/privatedtor.h
@@ -9,27 +9,28 @@
 class PrivateDtor
 {
 public:
-    inline static PrivateDtor* instance()
+    LIBMINIMAL_DISABLE_COPY_MOVE(PrivateDtor)
+
+    inline static PrivateDtor *instance()
     {
         static PrivateDtor self;
-        self.m_instanciations++;
+        self.m_instantiations++;
         return &self;
     }
 
     inline int instanceCalls()
     {
-        return m_instanciations;
+        return m_instantiations;
     }
 
 protected:
-    inline int protectedInstanceCalls() { return m_instanciations; }
+    inline int protectedInstanceCalls() { return m_instantiations; }
 
 private:
-    int m_instanciations;
+    int m_instantiations = 0;
 
-    PrivateDtor() : m_instanciations(0) {}
-    PrivateDtor(const PrivateDtor&) {}
-    ~PrivateDtor() {}
+    PrivateDtor() noexcept = default;
+    ~PrivateDtor() = default;
 };
 
-#endif
+#endif // PRIVATEDTOR_H
diff --git a/sources/shiboken6/tests/libsample/protected.h b/sources/shiboken6/tests/libsample/protected.h
index 5f2c788fb..059cced5d 100644
--- a/sources/shiboken6/tests/libsample/protected.h
+++ b/sources/shiboken6/tests/libsample/protected.h
@@ -7,24 +7,28 @@
 #include "libsamplemacros.h"
 #include "objecttype.h"
 #include "point.h"
+
 #include <string>
 #include <list>
 
 class LIBSAMPLE_API ProtectedNonPolymorphic
 {
 public:
+    LIBMINIMAL_DEFAULT_COPY_MOVE(ProtectedNonPolymorphic)
+
     explicit ProtectedNonPolymorphic(const char *name) : m_name(name) {}
-    ~ProtectedNonPolymorphic() {}
+    ~ProtectedNonPolymorphic() = default;
 
-    inline const char* publicName() { return m_name.c_str(); }
+    inline const char *publicName() { return m_name.c_str(); }
 
-    inline static ProtectedNonPolymorphic* create() { return new ProtectedNonPolymorphic("created"); }
+    inline static ProtectedNonPolymorphic *create()
+    { return new ProtectedNonPolymorphic("created"); }
 
 protected:
-    inline const char* protectedName() { return m_name.c_str(); }
+    inline const char *protectedName() { return m_name.c_str(); }
     inline int protectedSum(int a0, int a1) { return a0 + a1; }
     inline int modifiedProtectedSum(int a0, int a1) { return a0 + a1; }
-    inline static const char* protectedStatic() { return "protectedStatic"; }
+    inline static const char *protectedStatic() { return "protectedStatic"; }
     const char *dataTypeName(void *data = nullptr) const;
     const char *dataTypeName(int data) const;
 
@@ -35,15 +39,18 @@ private:
 class LIBSAMPLE_API ProtectedPolymorphic
 {
 public:
+    LIBMINIMAL_DEFAULT_COPY_MOVE(ProtectedPolymorphic)
+
     explicit ProtectedPolymorphic(const char *name) : m_name(name) {}
-    virtual ~ProtectedPolymorphic() {}
+    virtual ~ProtectedPolymorphic() = default;
 
-    inline static ProtectedPolymorphic* create() { return new ProtectedPolymorphic("created"); }
-    inline const char* publicName() { return m_name.c_str(); }
-    inline const char* callProtectedName() { return protectedName(); }
+    inline static ProtectedPolymorphic *create()
+    { return new ProtectedPolymorphic("created"); }
+    inline const char *publicName() { return m_name.c_str(); }
+    inline const char *callProtectedName() { return protectedName(); }
 
 protected:
-    virtual const char* protectedName() { return m_name.c_str(); }
+    virtual const char *protectedName() { return m_name.c_str(); }
 
 private:
     std::string m_name;
@@ -52,22 +59,29 @@ private:
 class LIBSAMPLE_API ProtectedPolymorphicDaughter : public ProtectedPolymorphic
 {
 public:
-    explicit ProtectedPolymorphicDaughter(const char *name) : ProtectedPolymorphic(name) {}
-    inline static ProtectedPolymorphicDaughter* create() { return new ProtectedPolymorphicDaughter("created"); }
+    explicit ProtectedPolymorphicDaughter(const char *name) :
+        ProtectedPolymorphic(name) {}
+    inline static ProtectedPolymorphicDaughter *create()
+    { return new ProtectedPolymorphicDaughter("created"); }
 };
 
 class LIBSAMPLE_API ProtectedPolymorphicGrandDaughter: public ProtectedPolymorphicDaughter
 {
 public:
-    explicit ProtectedPolymorphicGrandDaughter(const char *name) : ProtectedPolymorphicDaughter(name) {}
-    inline static ProtectedPolymorphicGrandDaughter* create() { return new ProtectedPolymorphicGrandDaughter("created"); }
+    explicit ProtectedPolymorphicGrandDaughter(const char *name) :
+        ProtectedPolymorphicDaughter(name) {}
+    inline static ProtectedPolymorphicGrandDaughter *create()
+    { return new ProtectedPolymorphicGrandDaughter("created"); }
 };
 
 class LIBSAMPLE_API ProtectedVirtualDestructor
 {
 public:
-    ProtectedVirtualDestructor() {}
-    inline static ProtectedVirtualDestructor* create() { return new ProtectedVirtualDestructor(); }
+    LIBMINIMAL_DISABLE_COPY_MOVE(ProtectedVirtualDestructor)
+
+    ProtectedVirtualDestructor() noexcept = default;
+    inline static ProtectedVirtualDestructor *create()
+    { return new ProtectedVirtualDestructor(); }
     inline static int dtorCalled() { return dtor_called; }
     inline static void resetDtorCounter() { dtor_called = 0; }
 protected:
@@ -79,8 +93,10 @@ private:
 class LIBSAMPLE_API ProtectedEnumClass
 {
 public:
-    ProtectedEnumClass() {}
-    virtual ~ProtectedEnumClass() {}
+    LIBMINIMAL_DISABLE_COPY_MOVE(ProtectedEnumClass)
+
+    ProtectedEnumClass() noexcept = default;
+    virtual ~ProtectedEnumClass() = default;
     enum PublicEnum {
         PublicItem0,
         PublicItem1
@@ -90,36 +106,33 @@ protected:
         ProtectedItem0,
         ProtectedItem1
     };
-    ProtectedEnum callProtectedEnumMethod(ProtectedEnum in) { return protectedEnumMethod(in); }
-    inline PublicEnum callPublicEnumMethod(PublicEnum in) { return publicEnumMethod(in); }
+    ProtectedEnum callProtectedEnumMethod(ProtectedEnum in)
+    { return protectedEnumMethod(in); }
+    inline PublicEnum callPublicEnumMethod(PublicEnum in)
+    { return publicEnumMethod(in); }
 
     virtual ProtectedEnum protectedEnumMethod(ProtectedEnum in) { return in; }
     virtual PublicEnum publicEnumMethod(PublicEnum in) { return in; }
 };
 
-
 class LIBSAMPLE_API ProtectedProperty
 {
 public:
-    ProtectedProperty()
-        : protectedValueTypeProperty(Point(0, 0)),
-          protectedProperty(0),
-          protectedEnumProperty(Event::NO_EVENT),
-          protectedValueTypePointerProperty(nullptr),
-          protectedObjectTypeProperty(nullptr)
-    {}
+    ProtectedProperty() = default;
+
 protected:
     // This is deliberately the first member to test wrapper registration
     // for value type members sharing the same memory address.
-    Point protectedValueTypeProperty;
-    int protectedProperty;
+    Point protectedValueTypeProperty{0, 0};
+    int protectedProperty = 0;
     std::list<int> protectedContainerProperty;
-    Event::EventType protectedEnumProperty;
-    Point* protectedValueTypePointerProperty;
-    ObjectType* protectedObjectTypeProperty;
+    Event::EventType protectedEnumProperty = Event::NO_EVENT;
+    Point *protectedValueTypePointerProperty = nullptr;
+    ObjectType *protectedObjectTypeProperty = nullptr;
 };
 
-LIBSAMPLE_API inline ProtectedProperty* createProtectedProperty() {
+LIBSAMPLE_API inline ProtectedProperty *createProtectedProperty()
+{
     return new ProtectedProperty;
 }
 
diff --git a/sources/shiboken6/tests/libsample/rect.h b/sources/shiboken6/tests/libsample/rect.h
index ca3b1912d..53296d26c 100644
--- a/sources/shiboken6/tests/libsample/rect.h
+++ b/sources/shiboken6/tests/libsample/rect.h
@@ -9,53 +9,46 @@
 class LIBSAMPLE_API Rect
 {
 public:
-    Rect()
-    {
-        m_left = m_top = 0;
-        m_right = m_bottom = -1;
-    }
-    Rect(int left, int top, int right, int bottom)
+    LIBMINIMAL_DEFAULT_COPY_MOVE(Rect)
+
+    Rect() noexcept = default;
+    explicit Rect(int left, int top, int right, int bottom) noexcept
         : m_left(left), m_top(top), m_right(right), m_bottom(bottom) { }
-    ~Rect() {}
+    ~Rect() = default;
+
     inline int left() const { return m_left; }
     inline int top() const { return m_top; }
     inline int right() const { return m_right; }
     inline int bottom() const { return m_bottom; }
 private:
-    int m_left;
-    int m_top;
-    int m_right;
-    int m_bottom;
+    int m_left = 0;
+    int m_top = 0;
+    int m_right = -1;
+    int m_bottom = -1;
 };
 
 class LIBSAMPLE_API RectF
 {
 public:
-    RectF()
-    {
-        m_left = m_top = 0;
-        m_right = m_bottom = -1;
-    }
-    RectF(int left, int top, int right, int bottom)
+    LIBMINIMAL_DEFAULT_COPY_MOVE(RectF)
+
+    RectF() noexcept = default;
+    explicit RectF(int left, int top, int right, int bottom) noexcept
         : m_left(left), m_top(top), m_right(right), m_bottom(bottom) { }
-    RectF(const Rect& other)
-    {
-        m_left = other.left();
-        m_top = other.top();
-        m_right = other.right();
-        m_bottom = other.bottom();
-    }
-    ~RectF() {}
+    RectF(const Rect &other) noexcept :
+        m_left(other.left()), m_top(other.top()),
+        m_right(other.right()), m_bottom(other.bottom()) {}
+    ~RectF() = default;
+
     inline double left() const { return m_left; }
     inline double top() const { return m_top; }
     inline double right() const { return m_right; }
     inline double bottom() const { return m_bottom; }
 private:
-    double m_left;
-    double m_top;
-    double m_right;
-    double m_bottom;
+    double m_left = 0;
+    double m_top = 0;
+    double m_right = -1;
+    double m_bottom = -1;
 };
 
 #endif // RECT_H
-
diff --git a/sources/shiboken6/tests/libsample/reference.cpp b/sources/shiboken6/tests/libsample/reference.cpp
index 25db84bfd..29dcfc054 100644
--- a/sources/shiboken6/tests/libsample/reference.cpp
+++ b/sources/shiboken6/tests/libsample/reference.cpp
@@ -1,15 +1,13 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
 #include "reference.h"
 
-using namespace std;
+#include <iostream>
 
-void
-Reference::show() const
+void Reference::show() const
 {
-    cout << "Reference.objId: " << m_objId << ", address: " << this;
+    std::cout << "Reference.objId: " << m_objId << ", address: " << this;
 }
 
 Reference &Reference::returnMySecondArg(int, Reference &ref)
@@ -17,45 +15,37 @@ Reference &Reference::returnMySecondArg(int, Reference &ref)
     return ref;
 }
 
-int
-Reference::usesReferenceVirtual(Reference& r, int inc)
+int Reference::usesReferenceVirtual(Reference &r, int inc)
 {
     return r.m_objId + inc;
 }
 
-int
-Reference::usesConstReferenceVirtual(const Reference& r, int inc)
+int Reference::usesConstReferenceVirtual(const Reference &r, int inc)
 {
     return r.m_objId + inc;
 }
 
-int
-Reference::callUsesReferenceVirtual(Reference& r, int inc)
+int Reference::callUsesReferenceVirtual(Reference &r, int inc)
 {
     return usesReferenceVirtual(r, inc);
 }
 
-int
-Reference::callUsesConstReferenceVirtual(const Reference& r, int inc)
+int Reference::callUsesConstReferenceVirtual(const Reference &r, int inc)
 {
     return usesConstReferenceVirtual(r, inc);
 }
 
-void
-Reference::alterReferenceIdVirtual(Reference& r)
+void Reference::alterReferenceIdVirtual(Reference &r)
 {
     r.setObjId(r.objId() * Reference::multiplier());
 }
 
-void
-Reference::callAlterReferenceIdVirtual(Reference& r)
+void Reference::callAlterReferenceIdVirtual(Reference &r)
 {
     alterReferenceIdVirtual(r);
 }
 
-ObjTypeReference::~ObjTypeReference()
-{
-}
+ObjTypeReference::~ObjTypeReference() = default;
 
 ObjTypeReference &ObjTypeReference::returnMySecondArg(int, ObjTypeReference &ref)
 {
diff --git a/sources/shiboken6/tests/libsample/reference.h b/sources/shiboken6/tests/libsample/reference.h
index 1dc7aaf7c..52818d9ea 100644
--- a/sources/shiboken6/tests/libsample/reference.h
+++ b/sources/shiboken6/tests/libsample/reference.h
@@ -9,34 +9,37 @@
 class LIBSAMPLE_API Reference
 {
 public:
-    explicit Reference(int objId = -1)
+    LIBMINIMAL_DEFAULT_COPY_MOVE(Reference)
+
+    explicit Reference(int objId = -1) noexcept
             : m_objId(objId) {}
-    virtual ~Reference() {}
+    virtual ~Reference() = default;
 
-    inline int objId() { return m_objId; }
+    inline int objId() const { return m_objId; }
     inline void setObjId(int objId) { m_objId = objId; }
 
-    inline static int usesReference(Reference& r) { return r.m_objId; }
-    inline static int usesConstReference(const Reference& r) { return r.m_objId; }
+    inline static int usesReference(Reference &r) { return r.m_objId; }
+    inline static int usesConstReference(const Reference &r) { return r.m_objId; }
 
-    virtual int usesReferenceVirtual(Reference& r, int inc);
-    virtual int usesConstReferenceVirtual(const Reference& r, int inc);
+    virtual int usesReferenceVirtual(Reference &r, int inc);
+    virtual int usesConstReferenceVirtual(const Reference &r, int inc);
 
-    int callUsesReferenceVirtual(Reference& r, int inc);
-    int callUsesConstReferenceVirtual(const Reference& r, int inc);
+    int callUsesReferenceVirtual(Reference &r, int inc);
+    int callUsesConstReferenceVirtual(const Reference &r, int inc);
 
-    virtual void alterReferenceIdVirtual(Reference& r);
-    void callAlterReferenceIdVirtual(Reference& r);
+    virtual void alterReferenceIdVirtual(Reference &r);
+    void callAlterReferenceIdVirtual(Reference &r);
 
     void show() const;
 
     inline static int multiplier() { return 10; }
 
-    virtual Reference& returnMyFirstArg(Reference& ref) { return ref; }
-    virtual Reference& returnMySecondArg(int a, Reference &ref);
+    virtual Reference &returnMyFirstArg(Reference &ref) { return ref; }
+    virtual Reference &returnMySecondArg(int a, Reference &ref);
 
     // nonsense operator to test if Shiboken is ignoring dereference operators.
     int operator*() { return m_objId; }
+
 private:
     int m_objId;
 };
@@ -44,13 +47,16 @@ private:
 class LIBSAMPLE_API ObjTypeReference
 {
 public:
-    ObjTypeReference() {}
-    ObjTypeReference(const ObjTypeReference&) {}
+    LIBMINIMAL_DISABLE_MOVE(ObjTypeReference)
+
+    ObjTypeReference() noexcept = default;
+    ObjTypeReference(const ObjTypeReference &) noexcept = default;
+    ObjTypeReference &operator=(const ObjTypeReference &) = delete;
     virtual ~ObjTypeReference();
-    virtual ObjTypeReference& returnMyFirstArg(ObjTypeReference& ref) { return ref; }
+
+    virtual ObjTypeReference &returnMyFirstArg(ObjTypeReference &ref) { return ref; }
     virtual ObjTypeReference &returnMySecondArg(int a, ObjTypeReference &ref);
-    virtual ObjTypeReference& justAPureVirtualFunc(ObjTypeReference& ref) = 0;
+    virtual ObjTypeReference &justAPureVirtualFunc(ObjTypeReference &ref) = 0;
 };
 
 #endif // REFERENCE_H
-
diff --git a/sources/shiboken6/tests/libsample/removednamespaces.h b/sources/shiboken6/tests/libsample/removednamespaces.h
index 08b28fae5..669f2ebf0 100644
--- a/sources/shiboken6/tests/libsample/removednamespaces.h
+++ b/sources/shiboken6/tests/libsample/removednamespaces.h
@@ -46,4 +46,3 @@ namespace RemovedNamespace3
 } // namespace UnremovedNamespace
 
 #endif // REMOVEDNAMESPACE_H
-
diff --git a/sources/shiboken6/tests/libsample/sample.cpp b/sources/shiboken6/tests/libsample/sample.cpp
index 7437a341b..5b5f8588b 100644
--- a/sources/shiboken6/tests/libsample/sample.cpp
+++ b/sources/shiboken6/tests/libsample/sample.cpp
@@ -15,7 +15,7 @@ int sample::value() const
     return m_value;
 }
 
-bool operator==(const sample&s1, const sample&s2)
+bool operator==(const sample &s1, const sample &s2)
 {
     return s1.value() == s2.value();
 }
diff --git a/sources/shiboken6/tests/libsample/sample.h b/sources/shiboken6/tests/libsample/sample.h
index 756b4687e..27909571a 100644
--- a/sources/shiboken6/tests/libsample/sample.h
+++ b/sources/shiboken6/tests/libsample/sample.h
@@ -20,9 +20,9 @@ namespace sample
     };
 
     // shiboken must not generate richcompare for namespace sample
-    LIBSAMPLE_API bool operator==(const sample&s1, const sample&s2);
+    LIBSAMPLE_API bool operator==(const sample &s1, const sample &s2);
 
     const int INT_CONSTANT = 42;
 }
 
-#endif
+#endif // SAMPLE_H
diff --git a/sources/shiboken6/tests/libsample/samplenamespace.cpp b/sources/shiboken6/tests/libsample/samplenamespace.cpp
index 8d1fa888f..eae5af2d2 100644
--- a/sources/shiboken6/tests/libsample/samplenamespace.cpp
+++ b/sources/shiboken6/tests/libsample/samplenamespace.cpp
@@ -1,12 +1,11 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
-#include <cstdlib>
-#include <time.h>
 #include "samplenamespace.h"
 
-using namespace std;
+#include <iostream>
+#include <cstdlib>
+#include <ctime>
 
 namespace SampleNamespace
 {
@@ -18,45 +17,43 @@ SomeClass::PublicScopedEnum SomeClass::protectedMethodReturningPublicScopedEnum(
     return PublicScopedEnum::v1;
 }
 
-OutValue
-enumInEnumOut(InValue in)
+OutValue enumInEnumOut(InValue in)
 {
-    OutValue retval;
+    auto retval = OutValue(-1);
     switch(in) {
-        case ZeroIn:
-            retval = ZeroOut;
-            break;
-        case OneIn:
-            retval = OneOut;
-            break;
-        case TwoIn:
-            retval = TwoOut;
-            break;
-        default:
-            retval = (OutValue) -1;
+    case ZeroIn:
+        retval = ZeroOut;
+        break;
+    case OneIn:
+        retval = OneOut;
+        break;
+    case TwoIn:
+        retval = TwoOut;
+        break;
+    default:
+        break;
     }
     return retval;
 }
 
-Option
-enumArgumentWithDefaultValue(Option opt)
+Option enumArgumentWithDefaultValue(Option opt)
 {
     return opt;
 }
 
-int
-getNumber(Option opt)
+int getNumber(Option opt)
 {
     int retval;
     switch(opt) {
-        case RandomNumber:
-            retval = rand() % 100;
-            break;
-        case UnixTime:
-            retval = (int) time(nullptr);
-            break;
-        default:
-            retval = 0;
+    case RandomNumber:
+        retval = rand() % 100;
+        break;
+    case UnixTime:
+        retval = int(std::time(nullptr));
+        break;
+    default:
+        retval = 0;
+        break;
     }
     return retval;
 }
@@ -68,8 +65,7 @@ void doSomethingWithArray(const unsigned char *, unsigned int, const char *)
     // to check compilation issues, i.e. if it compiles, it's ok.
 }
 
-int
-enumItemAsDefaultValueToIntArgument(int value)
+int enumItemAsDefaultValueToIntArgument(int value)
 {
     return value;
 }
@@ -90,14 +86,12 @@ void forceDecisorSideB(int, const Point &, const Str &, ObjectType *)
 {
 }
 
-double
-passReferenceToValueType(const Point& point, double multiplier)
+double passReferenceToValueType(const Point &point, double multiplier)
 {
     return (point.x() + point.y()) * multiplier;
 }
 
-int
-passReferenceToObjectType(const ObjectType& obj, int multiplier)
+int passReferenceToObjectType(const ObjectType &obj, int multiplier)
 {
     return obj.objectName().size() * multiplier;
 }
diff --git a/sources/shiboken6/tests/libsample/samplenamespace.h b/sources/shiboken6/tests/libsample/samplenamespace.h
index da75ead50..99a0787ee 100644
--- a/sources/shiboken6/tests/libsample/samplenamespace.h
+++ b/sources/shiboken6/tests/libsample/samplenamespace.h
@@ -4,12 +4,13 @@
 #ifndef SAMPLENAMESPACE_H
 #define SAMPLENAMESPACE_H
 
-#include <list>
 #include "libsamplemacros.h"
 #include "str.h"
 #include "point.h"
 #include "objecttype.h"
 
+#include <list>
+
 // Anonymous global enum
 enum {
     AnonymousGlobalEnum_Value0,
@@ -25,10 +26,10 @@ inline namespace InlineNamespace
 
     class LIBSAMPLE_API ClassWithinInlineNamespace {
     public:
-        ClassWithinInlineNamespace() = default;
+        LIBMINIMAL_DEFAULT_COPY_MOVE(ClassWithinInlineNamespace)
+
+        ClassWithinInlineNamespace() noexcept = default;
         ~ClassWithinInlineNamespace() = default;
-        ClassWithinInlineNamespace(const ClassWithinInlineNamespace &) = default;
-        ClassWithinInlineNamespace& operator=(const ClassWithinInlineNamespace &) = default;
 
         void setValue(EnumWithinInlineNamespace v) { m_value = v; }
         EnumWithinInlineNamespace value() const { return m_value; }
@@ -74,7 +75,8 @@ inline double powerOfTwo(double num) {
     return num * num;
 }
 
-LIBSAMPLE_API void doSomethingWithArray(const unsigned char *data, unsigned int size, const char *format = nullptr);
+LIBSAMPLE_API void doSomethingWithArray(const unsigned char *data, unsigned int size,
+                                        const char *format = nullptr);
 
 LIBSAMPLE_API int enumItemAsDefaultValueToIntArgument(int value = ZeroIn);
 
@@ -89,7 +91,10 @@ public:
         class OkThisIsRecursiveEnough
         {
         public:
-            virtual ~OkThisIsRecursiveEnough() {}
+            LIBMINIMAL_DISABLE_COPY_MOVE(OkThisIsRecursiveEnough)
+
+            OkThisIsRecursiveEnough() noexcept = default;
+            virtual ~OkThisIsRecursiveEnough() = default;
             enum NiceEnum {
                 NiceValue1, NiceValue2
             };
@@ -98,8 +103,9 @@ public:
                 NiceClassValue1, NiceClassValue2
             };
 
-            inline int someMethod(SomeInnerClass*) { return 0; }
-            virtual OkThisIsRecursiveEnough* someVirtualMethod(OkThisIsRecursiveEnough* arg) { return arg; }
+            inline int someMethod(SomeInnerClass *) { return 0; }
+            virtual OkThisIsRecursiveEnough *someVirtualMethod(OkThisIsRecursiveEnough *arg)
+            { return arg; }
         };
     protected:
         enum ProtectedEnum {
@@ -119,7 +125,8 @@ protected:
     PublicScopedEnum protectedMethodReturningPublicScopedEnum() const;
 };
 
-LIBSAMPLE_API inline int enumAsInt(SomeClass::PublicScopedEnum value) { return static_cast<int>(value); }
+LIBSAMPLE_API inline int enumAsInt(SomeClass::PublicScopedEnum value)
+{ return static_cast<int>(value); }
 
 class DerivedFromNamespace : public SomeClass::SomeInnerClass::OkThisIsRecursiveEnough
 {
@@ -128,29 +135,30 @@ public:
     // only to cause namespace confusion
 //    enum SampleNamespace {
 //    };
-    virtual OkThisIsRecursiveEnough* someVirtualMethod(OkThisIsRecursiveEnough* arg) { return arg; }
+    virtual OkThisIsRecursiveEnough *someVirtualMethod(OkThisIsRecursiveEnough *arg) { return arg; }
     inline OkThisIsRecursiveEnough *methodReturningTypeFromParentScope() { return nullptr; }
 };
 
 // The combination of the following two overloaded methods could trigger a
 // problematic behaviour on the overload decisor, if it isn't working properly.
 LIBSAMPLE_API void forceDecisorSideA(ObjectType *object = nullptr);
-LIBSAMPLE_API void forceDecisorSideA(const Point& pt, const Str& text, ObjectType* object = 0);
+LIBSAMPLE_API void forceDecisorSideA(const Point &pt, const Str &text,
+                                     ObjectType *object = nullptr);
 
 // The combination of the following two overloaded methods could trigger a
 // problematic behaviour on the overload decisor, if it isn't working properly.
 // This is a variation of forceDecisorSideB.
 LIBSAMPLE_API void forceDecisorSideB(int a, ObjectType *object = nullptr);
-LIBSAMPLE_API void forceDecisorSideB(int a, const Point &pt, const Str &text, ObjectType *object = nullptr);
+LIBSAMPLE_API void forceDecisorSideB(int a, const Point &pt, const Str &text,
+                                     ObjectType *object = nullptr);
 
 // Add a new signature on type system with only a Point value as parameter.
-LIBSAMPLE_API double passReferenceToValueType(const Point& point, double multiplier);
+LIBSAMPLE_API double passReferenceToValueType(const Point &point, double multiplier);
 // Add a new signature on type system with only a ObjectType pointer as parameter.
-LIBSAMPLE_API int passReferenceToObjectType(const ObjectType& obj, int multiplier);
+LIBSAMPLE_API int passReferenceToObjectType(const ObjectType &obj, int multiplier);
 
 extern LIBSAMPLE_API int variableInNamespace;
 
 } // namespace SampleNamespace
 
 #endif // SAMPLENAMESPACE_H
-
diff --git a/sources/shiboken6/tests/libsample/sbkdate.h b/sources/shiboken6/tests/libsample/sbkdate.h
index d102f62b8..5e1dd0b84 100644
--- a/sources/shiboken6/tests/libsample/sbkdate.h
+++ b/sources/shiboken6/tests/libsample/sbkdate.h
@@ -9,7 +9,7 @@
 class LIBSAMPLE_API SbkDate
 {
 public:
-    SbkDate(int d, int m, int y);
+    explicit SbkDate(int d, int m, int y);
 
     int day() const;
     int month() const;
@@ -22,4 +22,3 @@ private:
 };
 
 #endif // SBKDATE_H
-
diff --git a/sources/shiboken6/tests/libsample/simplefile.cpp b/sources/shiboken6/tests/libsample/simplefile.cpp
index e0e42e268..e51b14088 100644
--- a/sources/shiboken6/tests/libsample/simplefile.cpp
+++ b/sources/shiboken6/tests/libsample/simplefile.cpp
@@ -1,83 +1,73 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <stdlib.h>
-#include <string.h>
-#include <fstream>
 #include "simplefile.h"
 
-class SimpleFile_p
+#include <cstdlib>
+#include <cstdio>
+#include <string>
+#include <filesystem>
+
+class SimpleFilePrivate
 {
 public:
-    SimpleFile_p(const char* filename) : m_descriptor(nullptr), m_size(0)
-    {
-        m_filename = strdup(filename);
-    }
+    LIBMINIMAL_DISABLE_COPY_MOVE(SimpleFilePrivate)
 
-    ~SimpleFile_p()
-    {
-        free(m_filename);
-    }
+    SimpleFilePrivate(const char *filename) : m_filename(filename) {}
+    ~SimpleFilePrivate() = default;
 
-    char* m_filename;
-    FILE* m_descriptor;
-    long m_size;
+    std::string m_filename;
+    FILE *m_descriptor = nullptr;
+    long m_size = 0;
 };
 
-SimpleFile::SimpleFile(const char* filename)
+SimpleFile::SimpleFile(const char *filename) :
+    p(std::make_unique<SimpleFilePrivate>(filename))
 {
-    p = new SimpleFile_p(filename);
 }
 
 SimpleFile::~SimpleFile()
 {
     close();
-    delete p;
 }
 
-const char* SimpleFile::filename()
+const char *SimpleFile::filename()
 {
-    return p->m_filename;
+    return p->m_filename.c_str();
 }
 
-long SimpleFile::size()
+long SimpleFile::size() const
 {
     return p->m_size;
 }
 
-bool
-SimpleFile::open()
+bool SimpleFile::open()
 {
-    if ((p->m_descriptor = fopen(p->m_filename, "rb")) == nullptr)
+    auto *descriptor = std::fopen(p->m_filename.c_str(), "rb");
+    if (descriptor == nullptr)
         return false;
 
-    fseek(p->m_descriptor, 0, SEEK_END);
-    p->m_size = ftell(p->m_descriptor);
-    rewind(p->m_descriptor);
+    p->m_descriptor = descriptor;
+    const auto size = std::filesystem::file_size(std::filesystem::path(p->m_filename));
+    p->m_size = long(size);
 
     return true;
 }
 
-void
-SimpleFile::close()
+void SimpleFile::close()
 {
-    if (p->m_descriptor) {
-        fclose(p->m_descriptor);
+    if (p->m_descriptor != nullptr) {
+        std::fclose(p->m_descriptor);
         p->m_descriptor = nullptr;
     }
 }
 
-bool
-SimpleFile::exists() const
+bool SimpleFile::exists() const
 {
-    std::ifstream ifile(p->m_filename);
-    return !ifile.fail();
+    return std::filesystem::exists(std::filesystem::path(p->m_filename));
 }
 
-bool
-SimpleFile::exists(const char* filename)
+bool SimpleFile::exists(const char *filename)
 {
-    std::ifstream ifile(filename);
-    return !ifile.fail();
+    return std::filesystem::exists(std::filesystem::path(filename));
 }
-
diff --git a/sources/shiboken6/tests/libsample/simplefile.h b/sources/shiboken6/tests/libsample/simplefile.h
index 765b46095..e4612c944 100644
--- a/sources/shiboken6/tests/libsample/simplefile.h
+++ b/sources/shiboken6/tests/libsample/simplefile.h
@@ -5,27 +5,30 @@
 #define SIMPLEFILE_H
 
 #include "libsamplemacros.h"
-#include <stdio.h>
 
-class SimpleFile_p;
+#include <memory>
+
+class SimpleFilePrivate;
 
 class LIBSAMPLE_API SimpleFile
 {
 public:
-    explicit SimpleFile(const char* filename);
+    LIBMINIMAL_DISABLE_COPY(SimpleFile)
+    LIBMINIMAL_DEFAULT_MOVE(SimpleFile)
+
+    explicit SimpleFile(const char *filename);
     ~SimpleFile();
 
-    const char* filename();
-    long size();
+    const char *filename();
+    long size() const;
     bool open();
     void close();
 
     bool exists() const;
-    static bool exists(const char* filename);
+    static bool exists(const char *filename);
 
 private:
-    SimpleFile_p *p;
+    std::unique_ptr<SimpleFilePrivate> p;
 };
 
 #endif // SIMPLEFILE_H
-
diff --git a/sources/shiboken6/tests/libsample/size.cpp b/sources/shiboken6/tests/libsample/size.cpp
index 5edb8a77b..0291d6e86 100644
--- a/sources/shiboken6/tests/libsample/size.cpp
+++ b/sources/shiboken6/tests/libsample/size.cpp
@@ -1,14 +1,11 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <iostream>
 #include "size.h"
 
-using namespace std;
+#include <iostream>
 
-void
-Size::show() const
+void Size::show() const
 {
-    cout << "(width: " << m_width << ", height: " << m_height << ")";
+    std::cout << "(width: " << m_width << ", height: " << m_height << ")";
 }
-
diff --git a/sources/shiboken6/tests/libsample/size.h b/sources/shiboken6/tests/libsample/size.h
index ac57065af..2d194e96b 100644
--- a/sources/shiboken6/tests/libsample/size.h
+++ b/sources/shiboken6/tests/libsample/size.h
@@ -9,23 +9,26 @@
 class LIBSAMPLE_API Size
 {
 public:
-    Size(double width = 0.0, double height = 0.0) : m_width(width), m_height(height) {}
-    ~Size() {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(Size)
 
-    inline double width() { return m_width; }
+    explicit Size(double width = 0.0, double height = 0.0) noexcept :
+        m_width(width), m_height(height) {}
+    ~Size() = default;
+
+    inline double width() const { return m_width; }
     inline void setWidth(double width) { m_width = width; }
-    inline double height() { return m_height; }
+    inline double height() const { return m_height; }
     inline void setHeight(double height) { m_height = height; }
 
     inline double calculateArea() const { return m_width * m_height; }
 
     // Comparison Operators
-    inline bool operator<(const Size& other)
+    inline bool operator<(const Size &other)
     {
         return calculateArea() < other.calculateArea();
     }
 
-    inline bool operator>(const Size& other)
+    inline bool operator>(const Size &other)
     {
         // On some x86 hardware and compiler combinations, floating point
         // comparisons may fail due to a hardware bug. One workaround is to
@@ -37,7 +40,7 @@ public:
         return a > b;
     }
 
-    inline bool operator<=(const Size& other)
+    inline bool operator<=(const Size &other)
     {
         // See comments for operator>()
         double a = calculateArea();
@@ -45,7 +48,7 @@ public:
         return a <= b;
     }
 
-    inline bool operator>=(const Size& other)
+    inline bool operator>=(const Size &other)
     {
         return calculateArea() >= other.calculateArea();
     }
@@ -56,28 +59,28 @@ public:
     inline bool operator>=(double area) { return calculateArea() >= area; }
 
     // Arithmetic Operators
-    inline Size& operator+=(const Size& s)
+    inline Size &operator+=(const Size &s)
     {
         m_width += s.m_width;
         m_height += s.m_height;
         return *this;
     }
 
-    inline Size& operator-=(const Size& s)
+    inline Size &operator-=(const Size &s)
     {
         m_width -= s.m_width;
         m_height -= s.m_height;
         return *this;
     }
 
-    inline Size& operator*=(double mult)
+    inline Size &operator*=(double mult)
     {
         m_width *= mult;
         m_height *= mult;
         return *this;
     }
 
-    inline Size& operator/=(double div)
+    inline Size &operator/=(double div)
     {
         m_width /= div;
         m_height /= div;
@@ -89,11 +92,11 @@ public:
     // External operators
     friend inline bool operator==(const Size&, const Size&);
     friend inline bool operator!=(const Size&, const Size&);
-    friend inline const Size operator+(const Size&, const Size&);
-    friend inline const Size operator-(const Size&, const Size&);
-    friend inline const Size operator*(const Size&, double);
-    friend inline const Size operator*(double, const Size&);
-    friend inline const Size operator/(const Size&, double);
+    friend inline Size operator+(const Size&, const Size&);
+    friend inline Size operator-(const Size&, const Size&);
+    friend inline Size operator*(const Size&, double);
+    friend inline Size operator*(double, const Size&);
+    friend inline Size operator/(const Size&, double);
 
     friend inline bool operator<(double, const Size&);
     friend inline bool operator>(double, const Size&);
@@ -108,70 +111,71 @@ private:
 };
 
 // Comparison Operators
-inline bool operator!=(const Size& s1, const Size& s2)
+inline bool operator!=(const Size &s1, const Size &s2)
 {
     return s1.m_width != s2.m_width || s1.m_height != s2.m_height;
 }
 
-inline bool operator==(const Size& s1, const Size& s2)
+inline bool operator==(const Size &s1, const Size &s2)
 {
     return s1.m_width == s2.m_width && s1.m_height == s2.m_height;
 }
 
-inline bool operator<(double area, const Size& s)
+inline bool operator<(double area, const Size &s)
 {
     return area < s.calculateArea();
 }
 
-inline bool operator>(double area, const Size& s)
+inline bool operator>(double area, const Size &s)
 {
     return area > s.calculateArea();
 }
 
-inline bool operator<=(double area, const Size& s)
+inline bool operator<=(double area, const Size &s)
 {
     return area <= s.calculateArea();
 }
 
-inline bool operator>=(double area, const Size& s)
+inline bool operator>=(double area, const Size &s)
 {
     return area >= s.calculateArea();
 }
 
 // Arithmetic Operators
-inline const Size operator+(const Size& s1, const Size& s2)
+inline Size operator+(const Size &s1, const Size &s2)
 {
     return Size(s1.m_width + s2.m_width, s1.m_height + s2.m_height);
 }
 
-inline const Size operator-(const Size& s1, const Size& s2)
+inline Size operator-(const Size &s1, const Size &s2)
 {
     return Size(s1.m_width - s2.m_width, s1.m_height - s2.m_height);
 }
 
-inline const Size operator*(const Size& s, double mult)
+inline Size operator*(const Size &s, double mult)
 {
     return Size(s.m_width * mult, s.m_height * mult);
 }
 
-inline const Size operator*(double mult, const Size& s)
+inline Size operator*(double mult, const Size &s)
 {
     return Size(s.m_width * mult, s.m_height * mult);
 }
 
-inline const Size operator/(const Size& s, double div)
+inline Size operator/(const Size &s, double div)
 {
     return Size(s.m_width / div, s.m_height / div);
 }
 
 using real = double;
 using ushort = unsigned short;
+
 class LIBSAMPLE_API SizeF
 {
 public:
-    SizeF(real width, real height) : m_width(width), m_height(height) {}
-    real width() { return m_width; }
-    real height() { return m_height; }
+    explicit SizeF(real width, real height) : m_width(width), m_height(height) {}
+    real width() const { return m_width; }
+    real height() const { return m_height; }
     static inline ushort passTypedefOfUnsignedShort(ushort value) { return value; }
 private:
     real m_width;
@@ -179,4 +183,3 @@ private:
 };
 
 #endif // SIZE_H
-
diff --git a/sources/shiboken6/tests/libsample/sometime.cpp b/sources/shiboken6/tests/libsample/sometime.cpp
index 8a3802deb..ad9a0d81c 100644
--- a/sources/shiboken6/tests/libsample/sometime.cpp
+++ b/sources/shiboken6/tests/libsample/sometime.cpp
@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "sometime.h"
-#include <stdio.h>
 
-void
-Time::setTime()
+#include <cstdio>
+
+void Time::setTime()
 {
     m_hour = 0;
     m_minute = 0;
@@ -14,8 +14,7 @@ Time::setTime()
     m_is_null = true;
 }
 
-void
-Time::setTime(int h, int m, int s, int ms)
+void Time::setTime(int h, int m, int s, int ms)
 {
     m_hour = h;
     m_minute = m;
@@ -24,9 +23,7 @@ Time::setTime(int h, int m, int s, int ms)
     m_is_null = false;
 }
 
-
-Time::NumArgs
-Time::somethingCompletelyDifferent()
+Time::NumArgs Time::somethingCompletelyDifferent()
 {
     return ZeroArgs;
 }
@@ -40,18 +37,17 @@ Time::NumArgs Time::somethingCompletelyDifferent(int, int, ImplicitConv ic, Obje
     return ThreeArgs;
 }
 
-Str
-Time::toString() const
+Str Time::toString() const
 {
     if (m_is_null)
         return Str();
     char buffer[13];
-    snprintf(buffer, sizeof(buffer), "%02d:%02d:%02d.%03d", m_hour, m_minute, m_second, m_msec);
+    std::snprintf(buffer, sizeof(buffer), "%02d:%02d:%02d.%03d",
+                  m_hour, m_minute, m_second, m_msec);
     return Str(buffer);
 }
 
-bool
-Time::operator==(const Time& other) const
+bool Time::operator==(const Time &other) const
 {
     return m_hour == other.m_hour
             && m_minute == other.m_minute
@@ -60,8 +56,7 @@ Time::operator==(const Time& other) const
             && m_is_null == other.m_is_null;
 }
 
-bool
-Time::operator!=(const Time& other) const
+bool Time::operator!=(const Time &other) const
 {
     return !operator==(other);
 }
@@ -70,4 +65,3 @@ Time::operator Str() const
 {
     return Time::toString();
 }
-
diff --git a/sources/shiboken6/tests/libsample/sometime.h b/sources/shiboken6/tests/libsample/sometime.h
index 0e3442db0..575d4b136 100644
--- a/sources/shiboken6/tests/libsample/sometime.h
+++ b/sources/shiboken6/tests/libsample/sometime.h
@@ -12,6 +12,8 @@
 class LIBSAMPLE_API Time
 {
 public:
+    LIBMINIMAL_DEFAULT_COPY_MOVE(Time)
+
     enum NumArgs {
         ZeroArgs,
         TwoArgs,
@@ -19,14 +21,12 @@ public:
         FourArgs
     };
 
-    Time()
-        : m_hour(0), m_minute(0), m_second(0), m_msec(0), m_is_null(true)
-    {}
-    Time(int h, int m, int s = 0, int ms = 0)
-        : m_hour(h), m_minute(m), m_second(s), m_msec(ms), m_is_null(false)
+    Time() noexcept = default;
+    explicit Time(int h, int m, int s = 0, int ms = 0) noexcept:
+        m_hour(h), m_minute(m), m_second(s), m_msec(ms), m_is_null(false)
     {}
 
-    ~Time() {}
+    ~Time() = default;
 
     inline bool isNull() const { return m_is_null; }
 
@@ -48,20 +48,19 @@ public:
                                          ObjectType *type = nullptr);
 
     Str toString() const;
-    bool operator==(const Time& other) const;
-    bool operator!=(const Time& other) const;
+    bool operator==(const Time &other) const;
+    bool operator!=(const Time &other) const;
 
     // This cast operator must become an implicit conversion of Str.
     operator Str() const;
 
 private:
-    int m_hour;
-    int m_minute;
-    int m_second;
-    int m_msec;
+    int m_hour = 0;
+    int m_minute = 0;
+    int m_second = 0;
+    int m_msec = 0;
 
-    bool m_is_null;
+    bool m_is_null = true;
 };
 
 #endif // SOMETIME_H
-
diff --git a/sources/shiboken6/tests/libsample/stdcomplex.cpp b/sources/shiboken6/tests/libsample/stdcomplex.cpp
new file mode 100644
index 000000000..847174387
--- /dev/null
+++ b/sources/shiboken6/tests/libsample/stdcomplex.cpp
@@ -0,0 +1,32 @@
+// 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 "stdcomplex.h"
+
+#include <iostream>
+
+StdComplex::StdComplex() noexcept = default;
+
+StdComplex::StdComplex(double re, double img) noexcept : m_impl(re, img)
+{
+}
+
+StdComplex::operator int() const
+{
+    return std::lround(abs_value());
+}
+
+StdComplex::StdComplex(const Impl &impl) noexcept : m_impl(impl)
+{
+}
+
+StdComplex StdComplex::pow(const StdComplex &exp) const
+{
+    return StdComplex(std::pow(m_impl, exp.m_impl));
+}
+
+std::ostream &operator<<(std::ostream &str, const StdComplex &c)
+{
+    str << "Complex(" << c.real() << ", " << c.imag() << ')';
+    return str;
+}
diff --git a/sources/shiboken6/tests/libsample/stdcomplex.h b/sources/shiboken6/tests/libsample/stdcomplex.h
new file mode 100644
index 000000000..b39b80612
--- /dev/null
+++ b/sources/shiboken6/tests/libsample/stdcomplex.h
@@ -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
+
+#ifndef STDCOMPLEX_H
+#define STDCOMPLEX_H
+
+#include "libsamplemacros.h"
+
+#include <complex>
+#include <iosfwd>
+
+// A complex number based on std::complex for exercising esoteric number
+// protocols (Py_nb_). For standard number protocols, see Point.
+
+class LIBSAMPLE_API StdComplex
+{
+    using Impl = std::complex<double>;
+
+public:
+    StdComplex() noexcept;
+    explicit StdComplex(double re, double img) noexcept;
+
+    double real() const { return m_impl.real(); }
+    double imag() const { return m_impl.imag(); }
+
+    double abs_value() const { return std::abs(m_impl); } // abs() is reserved Python word
+
+    StdComplex pow(const StdComplex &exp) const;
+
+    operator double() const { return abs_value(); }
+    operator int() const;
+
+    friend inline bool operator==(const StdComplex &c1, const StdComplex &c2) noexcept
+    { return c1.m_impl == c2.m_impl; }
+    friend inline bool operator!=(const StdComplex &c1, const StdComplex &c2) noexcept
+    { return c1.m_impl != c2.m_impl; }
+
+    friend inline StdComplex operator+(const StdComplex &c1, const StdComplex &c2) noexcept
+    { return StdComplex(c1.m_impl + c2.m_impl); }
+    friend inline StdComplex operator-(const StdComplex &c1, const StdComplex &c2) noexcept
+    { return StdComplex(c1.m_impl - c2.m_impl); }
+    friend inline StdComplex operator*(const StdComplex &c1, const StdComplex &c2) noexcept
+    { return StdComplex(c1.m_impl * c2.m_impl); }
+    friend inline StdComplex operator/(const StdComplex &c1, const StdComplex &c2) noexcept
+    { return StdComplex(c1.m_impl / c2.m_impl); }
+
+private:
+    explicit StdComplex(const Impl &impl) noexcept;
+
+    Impl m_impl;
+};
+
+std::ostream &operator<<(std::ostream &str, const StdComplex &c);
+
+#endif // STDCOMPLEX_H
diff --git a/sources/shiboken6/tests/libsample/str.cpp b/sources/shiboken6/tests/libsample/str.cpp
index dd7909bef..742c0bb01 100644
--- a/sources/shiboken6/tests/libsample/str.cpp
+++ b/sources/shiboken6/tests/libsample/str.cpp
@@ -2,82 +2,73 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "str.h"
+
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <sstream>
 
-using namespace std;
-
 Str::Str(char c)
 {
     char str[2] = { c, 0 };
     init(str);
 }
 
-Str::Str(const char* cstr)
+Str::Str(const char *cstr)
 {
     init(cstr);
 }
 
-void
-Str::init(const char* cstr)
+void Str::init(const char *cstr)
 {
     if (cstr)
         m_str = cstr;
 }
 
-Str
-Str::arg(const Str& s) const
+Str Str::arg(const Str &s) const
 {
     size_t idx = m_str.find_first_of("%VAR");
-    if (idx == std::string::npos) {
+    if (idx == std::string::npos)
         return *this;
-    } else {
-        std::string result = m_str;
-        result.replace(idx, 4, s.m_str);
-        return result.c_str();
-    }
+
+    std::string result = m_str;
+    result.replace(idx, 4, s.m_str);
+    return result.c_str();
 }
 
-Str&
-Str::append(const Str& s)
+Str &Str::append(const Str &s)
 {
     m_str += s.m_str;
     return *this;
 }
 
-Str&
-Str::prepend(const Str& s)
+Str &Str::prepend(const Str &s)
 {
     m_str = s.m_str + m_str;
     return *this;
 }
 
-const char*
-Str::cstring() const
+const char *Str::cstring() const
 {
     return m_str.c_str();
 }
 
-int
-Str::toInt(bool* ok, int base) const
+int Str::toInt(bool *ok, int base) const
 {
-    bool my_ok;
     int result = 0;
-    istringstream conv(m_str);
+    std::istringstream conv(m_str);
     switch (base) {
-        case 8:
-            conv >> std::oct >> result;
-            break;
-        case 10:
-            conv >> std::dec >> result;
-            break;
-        case 16:
-            conv >> std::hex >> result;
-            break;
+    case 8:
+        conv >> std::oct >> result;
+        break;
+    case 10:
+        conv >> std::dec >> result;
+        break;
+    case 16:
+        conv >> std::hex >> result;
+        break;
     }
-    my_ok = istringstream::eofbit & conv.rdstate();
+    const bool my_ok = std::istringstream::eofbit & conv.rdstate();
     if (!my_ok)
         result = 0;
     if (ok)
@@ -85,20 +76,17 @@ Str::toInt(bool* ok, int base) const
     return result;
 }
 
-void
-Str::show() const
+void Str::show() const
 {
-    printf("%s", cstring());
+    std::printf("%s", cstring());
 }
 
-char
-Str::get_char(int pos) const
+char Str::get_char(int pos) const
 {
     return m_str[pos];
 }
 
-bool
-Str::set_char(int pos, char ch)
+bool Str::set_char(int pos, char ch)
 {
     m_str[pos] = ch;
     return true;
@@ -106,42 +94,42 @@ Str::set_char(int pos, char ch)
 
 Str Str::operator+(int number) const
 {
-    ostringstream in;
+    std::ostringstream in;
     in << m_str << number;
     return in.str().c_str();
 }
 
-bool Str::operator==(const Str& other) const
+bool Str::operator==(const Str &other) const
 {
     return m_str == other.m_str;
 }
 
-Str operator+(int number, const Str& str)
+Str operator+(int number, const Str &str)
 {
-    ostringstream in;
+    std::ostringstream in;
     in << number << str.m_str;
     return in.str().c_str();
 }
 
-bool Str::operator<(const Str& other) const
+bool Str::operator<(const Str &other) const
 {
     return m_str < other.m_str;
 }
 
-unsigned int strHash(const Str& str)
+unsigned int strHash(const Str &str)
 {
     unsigned int result = 0;
     for (char c : str.m_str)
-        result = 5u * result + unsigned(c);
+        result = 5U * result + unsigned(c);
     return result;
 }
 
-void changePStr(PStr* pstr, const char* suffix)
+void changePStr(PStr *pstr, const char *suffix)
 {
     pstr->append(suffix);
 }
 
-void duplicatePStr(PStr* pstr)
+void duplicatePStr(PStr *pstr)
 {
     if (!pstr)
         return;
diff --git a/sources/shiboken6/tests/libsample/str.h b/sources/shiboken6/tests/libsample/str.h
index a58f34bdb..6b3386cef 100644
--- a/sources/shiboken6/tests/libsample/str.h
+++ b/sources/shiboken6/tests/libsample/str.h
@@ -3,22 +3,23 @@
 
 #ifndef STR_H
 #define STR_H
-#include <string>
 
 #include "libsamplemacros.h"
 
+#include <string>
+
 class LIBSAMPLE_API Str
 {
 public:
     Str(char c);
-    Str(const char* cstr = "");
+    Str(const char *cstr = "");
 
-    Str arg(const Str& s) const;
+    Str arg(const Str &s) const;
 
-    Str& append(const Str& s);
-    Str& prepend(const Str& s);
+    Str &append(const Str &s);
+    Str &prepend(const Str &s);
 
-    const char* cstring() const;
+    const char *cstring() const;
     char get_char(int pos) const;
     bool set_char(int pos, char ch);
 
@@ -26,26 +27,26 @@ public:
 
     void show() const;
 
-    inline int size() const { return m_str.size(); }
+    inline int size() const { return int(m_str.size()); }
 
     // nonsense operator just to test reverse operators
     Str operator+(int number) const;
-    bool operator==(const Str& other) const;
-    bool operator<(const Str& other) const;
+    bool operator==(const Str &other) const;
+    bool operator<(const Str &other) const;
 
 private:
-    void init(const char* cstr);
+    void init(const char *cstr);
     std::string m_str;
 
-    friend LIBSAMPLE_API Str operator+(int number, const Str& str);
-    friend LIBSAMPLE_API unsigned int strHash(const Str& str);
+    friend LIBSAMPLE_API Str operator+(int number, const Str &str);
+    friend LIBSAMPLE_API unsigned int strHash(const Str &str);
 };
 
-LIBSAMPLE_API Str operator+(int number, const Str& str);
-LIBSAMPLE_API unsigned int strHash(const Str& str);
+LIBSAMPLE_API Str operator+(int number, const Str &str);
+LIBSAMPLE_API unsigned int strHash(const Str &str);
 
 using PStr = Str;
-LIBSAMPLE_API void changePStr(PStr* pstr, const char* suffix);
+LIBSAMPLE_API void changePStr(PStr *pstr, const char *suffix);
 LIBSAMPLE_API void duplicatePStr(PStr *pstr = nullptr);
 
 #endif // STR_H
diff --git a/sources/shiboken6/tests/libsample/strlist.cpp b/sources/shiboken6/tests/libsample/strlist.cpp
index 845b83a0d..5840a0516 100644
--- a/sources/shiboken6/tests/libsample/strlist.cpp
+++ b/sources/shiboken6/tests/libsample/strlist.cpp
@@ -5,15 +5,13 @@
 
 #include <algorithm>
 
-bool
-StrList::operator==(const std::list<Str>& other) const
+bool StrList::operator==(const std::list<Str> &other) const
 {
     return size() == other.size()
         && std::equal(begin(), end(), other.begin());
 }
 
-Str
-StrList::join(const Str& sep) const
+Str StrList::join(const Str &sep) const
 {
     Str result;
     const auto i1 = begin();
diff --git a/sources/shiboken6/tests/libsample/strlist.h b/sources/shiboken6/tests/libsample/strlist.h
index eb89b4c58..01865a5b4 100644
--- a/sources/shiboken6/tests/libsample/strlist.h
+++ b/sources/shiboken6/tests/libsample/strlist.h
@@ -4,10 +4,10 @@
 #ifndef STRLIST_H
 #define STRLIST_H
 
-#include <list>
+#include "libsamplemacros.h"
 #include "str.h"
 
-#include "libsamplemacros.h"
+#include <list>
 
 class LIBSAMPLE_API StrList : public std::list<Str>
 {
@@ -19,24 +19,29 @@ public:
         ListOfStrCtor
     };
 
-    inline StrList() : m_ctorUsed(NoParamsCtor) {}
-    inline explicit StrList(const Str& str) : m_ctorUsed(StrCtor) { push_back(str); }
-    inline StrList(const std::list<Str>& lst) : std::list<Str>(lst), m_ctorUsed(ListOfStrCtor) {}
+    inline StrList() = default;
+    inline StrList(const std::list<Str> &lst) :
+        std::list<Str>(lst), m_ctorUsed(ListOfStrCtor) {}
+    inline explicit StrList(const Str &str) :
+        m_ctorUsed(StrCtor) { push_back(str); }
+    inline StrList(const StrList &lst) :
+        std::list<Str>(lst), m_ctorUsed(CopyCtor) {}
 
-    inline StrList(const StrList &lst) : std::list<Str>(lst), m_ctorUsed(CopyCtor) {}
     StrList(StrList &&) = default;
     StrList &operator=(const StrList &) = default;
     StrList &operator=(StrList &&) = default;
+    ~StrList() = default;
+
+    inline void append(const Str &str) { push_back(str); }
+    Str join(const Str &sep) const;
 
-    inline void append(Str str) { push_back(str); }
-    Str join(const Str& sep) const;
+    bool operator==(const std::list<Str> &other) const;
+    inline bool operator!=(const std::list<Str> &other) const { return !(*this == other); }
 
-    bool operator==(const std::list<Str>& other) const;
-    inline bool operator!=(const std::list<Str>& other) const { return !(*this == other); }
+    CtorEnum constructorUsed() const { return m_ctorUsed; }
 
-    CtorEnum constructorUsed() { return m_ctorUsed; }
 private:
-    CtorEnum m_ctorUsed;
+    CtorEnum m_ctorUsed = NoParamsCtor;
 };
 
 using PStrList = StrList;
diff --git a/sources/shiboken6/tests/libsample/templateptr.h b/sources/shiboken6/tests/libsample/templateptr.h
index e8145b90d..bf230c363 100644
--- a/sources/shiboken6/tests/libsample/templateptr.h
+++ b/sources/shiboken6/tests/libsample/templateptr.h
@@ -4,15 +4,16 @@
 #ifndef TEMPLATEPTR_H
 #define TEMPLATEPTR_H
 
-#include <utility>
-#include <list>
 #include "libsamplemacros.h"
 #include "blackbox.h"
 
+#include <utility>
+#include <list>
+
 class LIBSAMPLE_API TemplatePtr
 {
 public:
-	void dummy(std::list<std::pair<BlackBox *, BlackBox *> > & items);
+    void dummy(std::list<std::pair<BlackBox *, BlackBox *> > &items);
 };
 
-#endif
+#endif // TEMPLATEPTR_H
diff --git a/sources/shiboken6/tests/libsample/transform.cpp b/sources/shiboken6/tests/libsample/transform.cpp
index d23cb6179..5ccf5d1ed 100644
--- a/sources/shiboken6/tests/libsample/transform.cpp
+++ b/sources/shiboken6/tests/libsample/transform.cpp
@@ -4,37 +4,25 @@
 
 #include "transform.h"
 
-#ifdef _WIN32
-#include <math.h>
-#include <float.h>
-static inline bool isfinite(double a) { return _finite(a); }
-#else
 #include <cmath>
-#endif
 
-using namespace std;
-
-Point applyHomogeneousTransform(
-    const Point& in,
-    double m11, double m12, double m13,
-    double m21, double m22, double m23,
-    double m31, double m32, double m33,
-    bool* okay)
+Point applyHomogeneousTransform(const Point &in,
+                                double m11, double m12, double m13,
+                                double m21, double m22, double m23,
+                                double m31, double m32, double m33,
+                                bool *okay)
 {
     double x = m11 * in.x() + m12 * in.y() + m13;
     double y = m21 * in.x() + m22 * in.y() + m23;
     double w = m31 * in.x() + m32 * in.y() + m33;
 
-    if (isfinite(w) && fabs(w) > 1e-10)
-    {
+    if (std::isfinite(w) && fabs(w) > 1e-10) {
         if (okay)
             *okay = true;
-        return Point(x / w, y / w);
-    }
-    else
-    {
-        if (okay)
-            *okay = false;
-        return Point();
+        return {x / w, y / w};
     }
+
+    if (okay)
+        *okay = false;
+    return {};
 }
diff --git a/sources/shiboken6/tests/libsample/transform.h b/sources/shiboken6/tests/libsample/transform.h
index a39445c40..34ebf40d3 100644
--- a/sources/shiboken6/tests/libsample/transform.h
+++ b/sources/shiboken6/tests/libsample/transform.h
@@ -9,12 +9,10 @@
 
 #include "libsamplemacros.h"
 
-LIBSAMPLE_API Point
-applyHomogeneousTransform(
-    const Point& in,
-    double m11, double m12, double m13,
-    double m21, double m22, double m23,
-    double m31, double m32, double m33,
-    bool* okay);
+LIBSAMPLE_API Point applyHomogeneousTransform(const Point &in,
+                                              double m11, double m12, double m13,
+                                              double m21, double m22, double m23,
+                                              double m31, double m32, double m33,
+                                              bool *okay);
 
 #endif // TRANSFORM_H
diff --git a/sources/shiboken6/tests/libsample/valueandvirtual.h b/sources/shiboken6/tests/libsample/valueandvirtual.h
index 25391cc0c..799e11e40 100644
--- a/sources/shiboken6/tests/libsample/valueandvirtual.h
+++ b/sources/shiboken6/tests/libsample/valueandvirtual.h
@@ -4,18 +4,22 @@
 #ifndef VALUEANDVIRTUAL_H
 #define VALUEANDVIRTUAL_H
 
+#include "libsamplemacros.h"
+
 class ValueAndVirtual
 {
 public:
-    ValueAndVirtual(int id) : m_id(id) {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(ValueAndVirtual)
+
+    explicit ValueAndVirtual(int id) noexcept : m_id(id) {}
+    virtual ~ValueAndVirtual() = default;
 
     bool operator()(int id, int id2) { return id == id2; }
 
-    inline int id() { return m_id; }
-    virtual ~ValueAndVirtual() {};
+    inline int id() const { return m_id; }
+
 private:
     int m_id;
 };
 
 #endif // VALUEANDVIRTUAL_H
-
diff --git a/sources/shiboken6/tests/libsample/virtualmethods.cpp b/sources/shiboken6/tests/libsample/virtualmethods.cpp
index fa2247a69..515564664 100644
--- a/sources/shiboken6/tests/libsample/virtualmethods.cpp
+++ b/sources/shiboken6/tests/libsample/virtualmethods.cpp
@@ -5,14 +5,12 @@
 
 int VirtualDtor::dtor_called = 0;
 
-double
-VirtualMethods::virtualMethod0(Point pt, int val, Complex cpx, bool b)
+double VirtualMethods::virtualMethod0(Point pt, int val, Complex cpx, bool b)
 {
     return (pt.x() * pt.y() * val) + cpx.imag() + ((int) b);
 }
 
-bool
-VirtualMethods::createStr(const char* text, Str*& ret)
+bool VirtualMethods::createStr(const char *text, Str *&ret)
 {
     if (!text) {
         ret = nullptr;
@@ -23,8 +21,7 @@ VirtualMethods::createStr(const char* text, Str*& ret)
     return true;
 }
 
-void
-VirtualMethods::getMargins(int* left, int* top, int* right, int* bottom) const
+void VirtualMethods::getMargins(int *left, int *top, int *right, int *bottom) const
 {
     *left = m_left;
     *top = m_top;
diff --git a/sources/shiboken6/tests/libsample/virtualmethods.h b/sources/shiboken6/tests/libsample/virtualmethods.h
index 5a1438a4a..b7172ad0d 100644
--- a/sources/shiboken6/tests/libsample/virtualmethods.h
+++ b/sources/shiboken6/tests/libsample/virtualmethods.h
@@ -17,11 +17,10 @@
 class LIBSAMPLE_API VirtualMethods
 {
 public:
-    VirtualMethods(Str name = "VirtualMethods") : m_name(name)
-    {
-        m_left = m_top = m_right = m_bottom = 0;
-    }
-    virtual ~VirtualMethods() {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(VirtualMethods)
+
+    explicit VirtualMethods(Str name = "VirtualMethods") : m_name(name) {}
+    virtual ~VirtualMethods() = default;
 
     virtual double virtualMethod0(Point pt, int val, Complex cpx, bool b);
     double callVirtualMethod0(Point pt, int val, Complex cpx, bool b)
@@ -61,12 +60,14 @@ public:
     void callCallMe() { callMe(); }
 
     // Passing reference to pointers.
-    virtual bool createStr(const char* text, Str*& ret);
-    bool callCreateStr(const char* text, Str*& ret) { return createStr(text, ret); }
+    virtual bool createStr(const char *text, Str *&ret);
+    bool callCreateStr(const char *text, Str *&ret) { return createStr(text, ret); }
 
     // Return a non-binded method
-    std::list<Str> callStrListToStdList(const StrList& strList) { return strListToStdList(strList); }
-    virtual std::list<Str> strListToStdList(const StrList& strList ) { return strList; }
+    std::list<Str> callStrListToStdList(const StrList &strList)
+    { return strListToStdList(strList); }
+    virtual std::list<Str> strListToStdList(const StrList &strList )
+    { return strList; }
 
     void setMargins(int left, int top, int right, int bottom)
     {
@@ -75,8 +76,8 @@ public:
         m_right = right;
         m_bottom = bottom;
     }
-    virtual void getMargins(int* left, int* top, int* right, int* bottom) const;
-    void callGetMargins(int* left, int* top, int* right, int* bottom) const
+    virtual void getMargins(int *left, int *top, int *right, int *bottom) const;
+    void callGetMargins(int *left, int *top, int *right, int *bottom) const
     {
         getMargins(left, top, right, bottom);
     }
@@ -84,7 +85,7 @@ public:
     virtual int recursionOnModifiedVirtual(Str arg) const;
     int callRecursionOnModifiedVirtual(Str arg) const { return recursionOnModifiedVirtual(arg); }
 
-    virtual const Str & returnConstRef() const;
+    virtual const Str &returnConstRef() const;
 
     virtual int stringViewLength(std::string_view in) const;
 
@@ -94,10 +95,10 @@ protected:
 
 private:
     Str m_name;
-    int m_left;
-    int m_top;
-    int m_right;
-    int m_bottom;
+    int m_left = 0;
+    int m_top = 0;
+    int m_right = 0;
+    int m_bottom = 0;
 };
 
 class LIBSAMPLE_API VirtualDaughter : public VirtualMethods
@@ -128,10 +129,12 @@ public:
 class LIBSAMPLE_API VirtualDtor
 {
 public:
-    VirtualDtor() {}
+    LIBMINIMAL_DEFAULT_COPY_MOVE(VirtualDtor)
+
+    VirtualDtor() noexcept = default;
     virtual ~VirtualDtor() { dtor_called++; }
 
-    static VirtualDtor* create() { return new VirtualDtor(); }
+    static VirtualDtor *create() { return new VirtualDtor(); }
     static int dtorCalled() { return dtor_called; }
     static void resetDtorCounter() { dtor_called = 0; }
 
@@ -140,4 +143,3 @@ private:
 };
 
 #endif // VIRTUALMETHODS_H
-
diff --git a/sources/shiboken6/tests/libsample/voidholder.h b/sources/shiboken6/tests/libsample/voidholder.h
index b5e59ba3d..3f0f4d973 100644
--- a/sources/shiboken6/tests/libsample/voidholder.h
+++ b/sources/shiboken6/tests/libsample/voidholder.h
@@ -9,21 +9,24 @@
 class VoidHolder
 {
 public:
-    explicit VoidHolder(void *ptr = nullptr) : m_ptr(ptr) {}
-    ~VoidHolder() {}
-    inline void* voidPointer() { return m_ptr; }
-    inline static void* gimmeMeSomeVoidPointer()
+    LIBMINIMAL_DEFAULT_COPY_MOVE(VoidHolder)
+
+    explicit VoidHolder(void *ptr = nullptr) noexcept : m_ptr(ptr) {}
+    ~VoidHolder() = default;
+
+    inline void *voidPointer() { return m_ptr; }
+    inline static void *gimmeMeSomeVoidPointer()
     {
-        static void* pointerToSomething = new VoidHolder();
+        static void *pointerToSomething = new VoidHolder();
         return pointerToSomething;
     }
     void *takeVoidPointer(void *item)
     {
         return item;
     }
+
 private:
-    void* m_ptr;
+    void *m_ptr;
 };
 
 #endif // VOIDHOLDER_H
-
diff --git a/sources/shiboken6/tests/libsmart/CMakeLists.txt b/sources/shiboken6/tests/libsmart/CMakeLists.txt
index 1a3a989da..95f0cffd6 100644
--- a/sources/shiboken6/tests/libsmart/CMakeLists.txt
+++ b/sources/shiboken6/tests/libsmart/CMakeLists.txt
@@ -1,10 +1,19 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(libsmart)
 
 set(libsmart_SRC
-smart.cpp
-stdsharedptrtestbench.cpp
-stdoptionaltestbench.cpp
-stduniqueptrtestbench.cpp
+libsmartmacros.h
+smart.cpp smart.h
+smart_integer.h
+smart_obj.h
+smart_registry.h
+smart_sharedptr.h
+smart_test.h
+stdoptionaltestbench.cpp stdoptionaltestbench.h
+stdsharedptrtestbench.cpp stdsharedptrtestbench.h
+stduniqueptrtestbench.cpp stduniqueptrtestbench.h
 )
 
 add_library(libsmart SHARED ${libsmart_SRC})
diff --git a/sources/shiboken6/tests/libsmart/smart_integer.h b/sources/shiboken6/tests/libsmart/smart_integer.h
index f2381cabb..42a441a00 100644
--- a/sources/shiboken6/tests/libsmart/smart_integer.h
+++ b/sources/shiboken6/tests/libsmart/smart_integer.h
@@ -11,6 +11,8 @@ public:
     Integer();
     Integer(const Integer &other);
     Integer &operator=(const Integer &other);
+    Integer(Integer &&other) noexcept = default;
+    Integer &operator=(Integer &&other) noexcept = default;
     ~Integer();
     void printInteger() const;
 
@@ -58,6 +60,9 @@ public:
     Integer2();
     Integer2(const Integer2 &);
     Integer2 &operator=(const Integer2 &);
+    Integer2(Integer2 &&other) = delete;
+    Integer2 &operator=(Integer2 &&other) = delete;
+    ~Integer2() = default;
 };
 } // namespace Smart
 
diff --git a/sources/shiboken6/tests/libsmart/smart_obj.h b/sources/shiboken6/tests/libsmart/smart_obj.h
index 901d69696..9f4f8425d 100644
--- a/sources/shiboken6/tests/libsmart/smart_obj.h
+++ b/sources/shiboken6/tests/libsmart/smart_obj.h
@@ -17,6 +17,10 @@ namespace Smart { class Integer2; }
 class LIB_SMART_API Obj {
 public:
     Obj();
+    Obj(const Obj &other) = delete;
+    Obj &operator=(const Obj &other) = delete;
+    Obj(Obj &&other) = delete;
+    Obj &operator=(Obj &&other) = delete;
     virtual ~Obj();
 
     void printObj();
diff --git a/sources/shiboken6/tests/libsmart/smart_sharedptr.h b/sources/shiboken6/tests/libsmart/smart_sharedptr.h
index 7d0365dd0..dc665810a 100644
--- a/sources/shiboken6/tests/libsmart/smart_sharedptr.h
+++ b/sources/shiboken6/tests/libsmart/smart_sharedptr.h
@@ -20,6 +20,8 @@ struct SharedPtrBase
 template <class T>
 class SharedPtr : public SharedPtrBase {
 public:
+    LIBMINIMAL_DEFAULT_MOVE(SharedPtr)
+
     SharedPtr() { logDefaultConstructor(typeid(T).name(), this); }
 
     SharedPtr(T *v) : mPtr(v)
@@ -38,9 +40,10 @@ public:
         logCopyConstructor(typeid(T).name(), this, data());
     }
 
-    SharedPtr& operator=(const SharedPtr& other)
+    SharedPtr &operator=(const SharedPtr &other)
     {
-        mPtr = other.mPtr;
+        if (this != &other)
+            mPtr = other.mPtr;
         return *this;
     }
 
diff --git a/sources/shiboken6/tests/libsmart/stdsharedptrtestbench.cpp b/sources/shiboken6/tests/libsmart/stdsharedptrtestbench.cpp
index a7b73cc81..472f807f2 100644
--- a/sources/shiboken6/tests/libsmart/stdsharedptrtestbench.cpp
+++ b/sources/shiboken6/tests/libsmart/stdsharedptrtestbench.cpp
@@ -51,6 +51,46 @@ void StdSharedPtrTestBench::printInt(const std::shared_ptr<int> &p)
     std::cerr << '\n';
 }
 
+std::shared_ptr<double> StdSharedPtrTestBench::createDouble(double v)
+{
+     return std::make_shared<double>(v);
+}
+
+std::shared_ptr<double> StdSharedPtrTestBench::createNullDouble()
+{
+    return {};
+}
+
+void StdSharedPtrTestBench::printDouble(const std::shared_ptr<double> &p)
+{
+    std::cerr << __FUNCTION__ << ' ';
+    if (p.get())
+        std::cerr << *p;
+    else
+        std::cerr << "nullptr";
+    std::cerr << '\n';
+}
+
+std::shared_ptr<std::string> StdSharedPtrTestBench::createString(const char *text)
+{
+    return std::make_shared<std::string>(text);
+}
+
+std::shared_ptr<std::string> StdSharedPtrTestBench::createNullString()
+{
+    return {};
+}
+
+void StdSharedPtrTestBench::printString(const std::shared_ptr<std::string> &p)
+{
+    std::cerr << __FUNCTION__ << ' ';
+    if (p.get())
+        std::cerr << '"' << *p << '"';
+    else
+        std::cerr << "nullptr";
+    std::cerr << '\n';
+}
+
 StdSharedPtrVirtualMethodTester::StdSharedPtrVirtualMethodTester() = default;
 StdSharedPtrVirtualMethodTester::~StdSharedPtrVirtualMethodTester() = default;
 
diff --git a/sources/shiboken6/tests/libsmart/stdsharedptrtestbench.h b/sources/shiboken6/tests/libsmart/stdsharedptrtestbench.h
index 8991cded6..9d4c207b5 100644
--- a/sources/shiboken6/tests/libsmart/stdsharedptrtestbench.h
+++ b/sources/shiboken6/tests/libsmart/stdsharedptrtestbench.h
@@ -7,6 +7,7 @@
 #include "libsmartmacros.h"
 
 #include <memory>
+#include <string>
 
 class Integer;
 
@@ -23,6 +24,14 @@ public:
     static std::shared_ptr<int> createInt(int v = 42);
     static std::shared_ptr<int> createNullInt();
     static void printInt(const std::shared_ptr<int> &);
+
+    static std::shared_ptr<double> createDouble(double v = 42);
+    static std::shared_ptr<double> createNullDouble();
+    static void printDouble(const std::shared_ptr<double> &);
+
+    static std::shared_ptr<std::string> createString(const char *text);
+    static std::shared_ptr<std::string> createNullString();
+    static void printString(const std::shared_ptr<std::string> &);
 };
 
 class LIB_SMART_API StdSharedPtrVirtualMethodTester
diff --git a/sources/shiboken6/tests/minimalbinding/CMakeLists.txt b/sources/shiboken6/tests/minimalbinding/CMakeLists.txt
index 1b8c259e6..7f132bd34 100644
--- a/sources/shiboken6/tests/minimalbinding/CMakeLists.txt
+++ b/sources/shiboken6/tests/minimalbinding/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(minimal)
 
 set(minimal_TYPESYSTEM
@@ -6,9 +9,11 @@ ${CMAKE_CURRENT_SOURCE_DIR}/typesystem_minimal.xml
 
 set(minimal_SRC
 ${CMAKE_CURRENT_BINARY_DIR}/minimal/minimal_module_wrapper.cpp
+${CMAKE_CURRENT_BINARY_DIR}/minimal/containeruser_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/minimal/obj_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/minimal/val_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/minimal/listuser_wrapper.cpp
+${CMAKE_CURRENT_BINARY_DIR}/minimal/spanuser_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/minimal/minbooluser_wrapper.cpp
 )
 
diff --git a/sources/shiboken6/tests/minimalbinding/brace_pattern_test.py b/sources/shiboken6/tests/minimalbinding/brace_pattern_test.py
index f625fc776..946a869db 100644
--- a/sources/shiboken6/tests/minimalbinding/brace_pattern_test.py
+++ b/sources/shiboken6/tests/minimalbinding/brace_pattern_test.py
@@ -11,7 +11,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from shiboken6 import Shiboken
+from shiboken6 import Shiboken  # noqa: F401
 
 from shibokensupport.signature.lib.tool import build_brace_pattern
 
@@ -21,8 +21,9 @@ against a slower reference implementation.
 The pattern is crucial, because it is used heavily in signature.parser .
 """
 
-# A slow reference parser for braces and strings
+
 def check(s):
+    """A slow reference parser for braces and strings"""
     open, close = "[{(<", "]})>"
     escape, quote = "\\", '"'
     instring = blind = False
@@ -41,8 +42,7 @@ def check(s):
             stack.append(c)
         elif c in close:
             pos = close.index(c)
-            if ((len(stack) > 0) and
-                (open[pos] == stack[len(stack)-1])):
+            if len(stack) > 0 and open[pos] == stack[len(stack) - 1]:
                 stack.pop()
             else:
                 return False
diff --git a/sources/shiboken6/tests/minimalbinding/containeruser_test.py b/sources/shiboken6/tests/minimalbinding/containeruser_test.py
new file mode 100644
index 000000000..25d683957
--- /dev/null
+++ b/sources/shiboken6/tests/minimalbinding/containeruser_test.py
@@ -0,0 +1,44 @@
+#!/usr/bin/env 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
+
+import os
+import sys
+import unittest
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from shiboken_paths import init_paths
+init_paths()
+
+from minimal import ContainerUser
+
+
+class ContainerTest(unittest.TestCase):
+    """Simple test for converting std::vector and using an opaque container.
+        For advanced tests, see ListUser."""
+    def testVectorConversion(self):
+        v = ContainerUser.createIntVector(4)
+        self.assertEqual(ContainerUser.sumIntVector(v), 6)
+
+    def testVectorOpaqueContainer(self):
+        cu = ContainerUser()
+        oc = cu.intVector()
+        self.assertEqual(oc[0], 1)
+        oc[0] = 42
+        self.assertEqual(cu.intVector()[0], 42)
+
+    def testArrayConversion(self):
+        v = ContainerUser.createIntArray()
+        self.assertEqual(ContainerUser.sumIntArray(v), 6)
+
+    def testArrayOpaqueContainer(self):
+        cu = ContainerUser()
+        oc = cu.intArray()
+        self.assertEqual(oc[0], 1)
+        oc[0] = 42
+        self.assertEqual(cu.intArray()[0], 42)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/shiboken6/tests/minimalbinding/global.h b/sources/shiboken6/tests/minimalbinding/global.h
index 573e826d7..fc5c59a26 100644
--- a/sources/shiboken6/tests/minimalbinding/global.h
+++ b/sources/shiboken6/tests/minimalbinding/global.h
@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "obj.h"
+#include "containeruser.h"
 #include "val.h"
 #include "minbool.h"
 #include "listuser.h"
+#include "spanuser.h"
 #include "typedef.h"
diff --git a/sources/shiboken6/tests/minimalbinding/listuser_test.py b/sources/shiboken6/tests/minimalbinding/listuser_test.py
index fc108950f..b30bb653a 100644
--- a/sources/shiboken6/tests/minimalbinding/listuser_test.py
+++ b/sources/shiboken6/tests/minimalbinding/listuser_test.py
@@ -32,7 +32,7 @@ class ExtListUser(ListUser):
         return [not mb1, not mb2]
 
     def oredMinBoolList(self, minBoolList):
-        return not reduce(lambda a, b: a|b, minBoolList)
+        return not reduce(lambda a, b: a | b, minBoolList)
 
     def createValList(self, num):
         return [Val(i) for i in range(0, num * 2, 2)]
@@ -95,8 +95,14 @@ class IntListConversionTest(unittest.TestCase):
     def testSumIntList(self):
         lu = ListUser()
         lst = range(4)
-        self.assertEqual(lu.sumIntList(lst), sum(lst))
-        self.assertEqual(lu.callSumIntList(lst), sum(lst))
+        expected = sum(lst)
+        self.assertEqual(lu.sumIntList(lst), expected)
+        self.assertEqual(lu.callSumIntList(lst), expected)
+        self.assertEqual(lu.sumIntListDefaultParam(lst), expected)
+        self.assertEqual(lu.sumIntListDefaultParamConstRef(lst), expected)
+        # PYSIDE-2454: Check container default parameters (1,2,3)
+        self.assertEqual(lu.sumIntListDefaultParam(), 6)
+        self.assertEqual(lu.sumIntListDefaultParamConstRef(), 6)
 
     def testSumIntListFromExtendedClass(self):
         lu = ExtListUser()
@@ -297,14 +303,16 @@ class ListOfIntListConversionTest(unittest.TestCase):
     def testSumListOfIntListsFromExtendedClass(self):
         lu = ExtListUser()
         lst = [range(4)] * 4
-        self.assertEqual(lu.sumListOfIntLists(lst), sum([sum(line) for line in [range(4)] * 4]) * 2)
-        self.assertEqual(lu.callSumListOfIntLists(lst), sum([sum(line) for line in [range(4)] * 4]) * 2)
+        self.assertEqual(lu.sumListOfIntLists(lst),
+                         sum([sum(line) for line in [range(4)] * 4]) * 2)
+        self.assertEqual(lu.callSumListOfIntLists(lst),
+                         sum([sum(line) for line in [range(4)] * 4]) * 2)
 
     def testOpaqueContainer(self):
         lu = ListUser()
 
         # Set via Python
-        python_list = [1,2]
+        python_list = [1, 2]
         lu.setStdIntList(python_list)
         self.assertEqual(len(lu.m_stdIntList), 2)
         self.assertEqual(lu.m_stdIntList[0], 1)
@@ -325,8 +333,8 @@ class ListOfIntListConversionTest(unittest.TestCase):
         self.assertEqual(lu.m_stdIntList[2], 5)
 
         # Access list via getter
-        l = lu.getIntList()
-        l.append(6)
+        il = lu.getIntList()
+        il.append(6)
         self.assertEqual(len(lu.m_stdIntList), 4)
         self.assertEqual(lu.m_stdIntList[3], 6)
 
diff --git a/sources/shiboken6/tests/minimalbinding/minbool_test.py b/sources/shiboken6/tests/minimalbinding/minbool_test.py
index 331b410b3..d9ce0eac0 100644
--- a/sources/shiboken6/tests/minimalbinding/minbool_test.py
+++ b/sources/shiboken6/tests/minimalbinding/minbool_test.py
@@ -13,32 +13,34 @@ init_paths()
 
 from minimal import MinBoolUser
 
+
 class DerivedMinBoolUser (MinBoolUser):
     def returnMyselfVirtual(self):
         return MinBoolUser()
 
+
 class MinBoolTest(unittest.TestCase):
 
     def testMinBoolUser(self):
         mbuTrue = MinBoolUser()
         mbuFalse = MinBoolUser()
         mbuTrue.setMinBool(True)
-        self.assertEqual(mbuFalse.minBool(), False)
-        self.assertEqual(mbuTrue.minBool(), True)
-        self.assertEqual(mbuTrue.callInvertedMinBool(), False)
+        self.assertFalse(mbuFalse.minBool())
+        self.assertTrue(mbuTrue.minBool())
+        self.assertFalse(mbuTrue.callInvertedMinBool())
 
-        self.assertEqual(mbuTrue.minBool() == True, True)
-        self.assertEqual(False == mbuFalse.minBool(), True)
-        self.assertEqual(mbuTrue.minBool() == mbuFalse.minBool(), False)
+        self.assertTrue(mbuTrue.minBool())
+        self.assertFalse(mbuFalse.minBool())
+        self.assertTrue(mbuTrue.minBool() != mbuFalse.minBool())
 
-        self.assertEqual(mbuFalse.minBool() != True, True)
-        self.assertEqual(True != mbuFalse.minBool(), True)
-        self.assertEqual(mbuTrue.minBool() != mbuFalse.minBool(), True)
+        self.assertFalse(mbuFalse.minBool())
+        self.assertFalse(mbuFalse.minBool())
+        self.assertTrue(mbuTrue.minBool() != mbuFalse.minBool())
 
     def testVirtuals(self):
         dmbu = DerivedMinBoolUser()
         self.assertEqual(dmbu.invertedMinBool(), True)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/minimalbinding/minimalbinding.pyproject b/sources/shiboken6/tests/minimalbinding/minimalbinding.pyproject
index d68e3811f..ab19dc443 100644
--- a/sources/shiboken6/tests/minimalbinding/minimalbinding.pyproject
+++ b/sources/shiboken6/tests/minimalbinding/minimalbinding.pyproject
@@ -1,5 +1,6 @@
 {
     "files": ["brace_pattern_test.py",
+              "containeruser_test.py",
               "listuser_test.py",
               "minbool_test.py",
               "obj_test.py",
diff --git a/sources/shiboken6/tests/minimalbinding/obj_test.py b/sources/shiboken6/tests/minimalbinding/obj_test.py
index 0d8a2dced..e873845de 100644
--- a/sources/shiboken6/tests/minimalbinding/obj_test.py
+++ b/sources/shiboken6/tests/minimalbinding/obj_test.py
@@ -12,6 +12,7 @@ from shiboken_paths import init_paths
 init_paths()
 from minimal import Obj
 
+
 class ExtObj(Obj):
     def __init__(self, objId):
         Obj.__init__(self, objId)
@@ -91,4 +92,3 @@ class ObjTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/minimalbinding/spanuser_test.py b/sources/shiboken6/tests/minimalbinding/spanuser_test.py
new file mode 100644
index 000000000..6db6aa616
--- /dev/null
+++ b/sources/shiboken6/tests/minimalbinding/spanuser_test.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env 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
+
+import os
+import sys
+import unittest
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from shiboken_paths import init_paths
+init_paths()
+
+from minimal import SpanUser
+
+
+class IntSpanTest(unittest.TestCase):
+
+    def testCreateIntSpan(self):
+        if not SpanUser.enabled():
+            return
+        expected = [1, 2, 3]
+        self.assertEqual(SpanUser.getIntSpan3(), expected)
+        self.assertEqual(SpanUser.getIntSpan(), expected)
+        self.assertEqual(SpanUser.getConstIntSpan3(), expected)
+
+        self.assertEqual(SpanUser.sumIntSpan3(expected), 6)
+        self.assertEqual(SpanUser.sumIntSpan(expected), 6)
+        self.assertEqual(SpanUser.sumConstIntSpan3(expected), 6)
+
+    def testSpanOpaqueContainer(self):
+        if not SpanUser.enabled():
+            return
+        oc = SpanUser.getIntSpan3_OpaqueContainer()  # 1,2,3
+        oc[1] = 10
+        oc = SpanUser.getIntSpan3_OpaqueContainer()
+        # note: This converts to std::vector
+        self.assertEqual(SpanUser.sumIntSpan3(oc), 14)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/shiboken6/tests/minimalbinding/typedef_test.py b/sources/shiboken6/tests/minimalbinding/typedef_test.py
index 1d878be30..c2fc8fc12 100644
--- a/sources/shiboken6/tests/minimalbinding/typedef_test.py
+++ b/sources/shiboken6/tests/minimalbinding/typedef_test.py
@@ -2,7 +2,6 @@
 # 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 reduce
 import os
 import sys
 import unittest
@@ -11,7 +10,9 @@ from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
-from minimal import *
+from minimal import (arrayFunc, arrayFuncInt, arrayFuncIntReturn,
+                     arrayFuncIntReturnTypedef, arrayFuncIntTypedef,
+                     arrayFuncReturn, arrayFuncReturnTypedef, arrayFuncTypedef)
 
 try:
     import numpy as np
@@ -31,29 +32,37 @@ class TypedefTest(unittest.TestCase):
         self.assertTrue(arrayFuncInt(none), "None is empty, arrayFuncInt should return true")
         self.assertFalse(arrayFuncInt(full), "Full is NOT empty, arrayFuncInt should return false")
 
-        self.assertTrue(arrayFuncInt(np.array(none)), "None is empty, arrayFuncInt should return true")
-        self.assertFalse(arrayFuncInt(np.array(full)), "Full is NOT empty, arrayFuncInt should return false")
+        self.assertTrue(arrayFuncInt(np.array(none)),
+                        "None is empty, arrayFuncInt should return true")
+        self.assertFalse(arrayFuncInt(np.array(full)),
+                         "Full is NOT empty, arrayFuncInt should return false")
 
     def test_arrayFuncIntTypedef(self):
         none = ()
         full = (1, 2, 3)
-        self.assertTrue(arrayFuncIntTypedef(none), "None is empty, arrayFuncIntTypedef should return true")
-        self.assertFalse(arrayFuncIntTypedef(full), "Full is NOT empty, arrayFuncIntTypedef should return false")
+        self.assertTrue(arrayFuncIntTypedef(none),
+                        "None is empty, arrayFuncIntTypedef should return true")
+        self.assertFalse(arrayFuncIntTypedef(full),
+                         "Full is NOT empty, arrayFuncIntTypedef should return false")
 
-        self.assertTrue(arrayFuncIntTypedef(np.array(none)), "None is empty, arrayFuncIntTypedef should return true")
-        self.assertFalse(arrayFuncIntTypedef(np.array(full)), "Full is NOT empty, arrayFuncIntTypedef should return false")
+        self.assertTrue(arrayFuncIntTypedef(np.array(none)),
+                        "None is empty, arrayFuncIntTypedef should return true")
+        self.assertFalse(arrayFuncIntTypedef(np.array(full)),
+                         "Full is NOT empty, arrayFuncIntTypedef should return false")
 
     def test_arrayFuncIntReturn(self):
         none = arrayFuncIntReturn(0)
         full = arrayFuncIntReturn(self.the_size)
         self.assertTrue((len(none) == 0), "none should be empty")
-        self.assertTrue((len(full) == self.the_size), "full should have " + str(self.the_size) + " elements")
+        self.assertTrue((len(full) == self.the_size),
+                        f"full should have {self.the_size} elements")
 
     def test_arrayFuncIntReturnTypedef(self):
         none = arrayFuncIntReturnTypedef(0)
         full = arrayFuncIntReturnTypedef(self.the_size)
         self.assertTrue((len(none) == 0), "none should be empty")
-        self.assertTrue((len(full) == self.the_size), "full should have " + str(self.the_size) + " elements")
+        self.assertTrue((len(full) == self.the_size),
+                        f"full should have {self.the_size} elements")
 
     def test_arrayFunc(self):
         none = ()
@@ -62,30 +71,37 @@ class TypedefTest(unittest.TestCase):
         self.assertFalse(arrayFunc(full), "Full is NOT empty, arrayFunc should return false")
 
         self.assertTrue(arrayFunc(np.array(none)), "None is empty, arrayFunc should return true")
-        self.assertFalse(arrayFunc(np.array(full)), "Full is NOT empty, arrayFunc should return false")
+        self.assertFalse(arrayFunc(np.array(full)),
+                         "Full is NOT empty, arrayFunc should return false")
 
     def test_arrayFuncTypedef(self):
         none = ()
         full = (1, 2, 3)
-        self.assertTrue(arrayFuncTypedef(none), "None is empty, arrayFuncTypedef should return true")
-        self.assertFalse(arrayFuncTypedef(full), "Full is NOT empty, arrayFuncTypedef should return false")
+        self.assertTrue(arrayFuncTypedef(none),
+                        "None is empty, arrayFuncTypedef should return true")
+        self.assertFalse(arrayFuncTypedef(full),
+                         "Full is NOT empty, arrayFuncTypedef should return false")
 
-        self.assertTrue(arrayFuncTypedef(np.array(none)), "None is empty, arrayFuncTypedef should return true")
-        self.assertFalse(arrayFuncTypedef(np.array(full)), "Full is NOT empty, arrayFuncTypedef should return false")
+        self.assertTrue(arrayFuncTypedef(np.array(none)),
+                        "None is empty, arrayFuncTypedef should return true")
+        self.assertFalse(arrayFuncTypedef(np.array(full)),
+                         "Full is NOT empty, arrayFuncTypedef should return false")
 
     def test_arrayFuncReturn(self):
         none = arrayFuncReturn(0)
         full = arrayFuncReturn(self.the_size)
         self.assertTrue((len(none) == 0), "none should be empty")
-        self.assertTrue((len(full) == self.the_size), "full should have " + str(self.the_size) + " elements")
+        self.assertTrue((len(full) == self.the_size),
+                        f"full should have {self.the_size} elements")
 
     def test_arrayFuncReturnTypedef(self):
         none = arrayFuncReturnTypedef(0)
         full = arrayFuncReturnTypedef(self.the_size)
         self.assertTrue((len(none) == 0), "none should be empty")
-        self.assertTrue((len(full) == self.the_size), "full should have " + str(self.the_size) + " elements")
+        self.assertTrue((len(full) == self.the_size),
+                        f"full should have {self.the_size} elements")
 
 
 if __name__ == '__main__':
-    if np != None:
+    if np is not None:
         unittest.main()
diff --git a/sources/shiboken6/tests/minimalbinding/typesystem_minimal.xml b/sources/shiboken6/tests/minimalbinding/typesystem_minimal.xml
index 3fac1b2b3..e18bf8686 100644
--- a/sources/shiboken6/tests/minimalbinding/typesystem_minimal.xml
+++ b/sources/shiboken6/tests/minimalbinding/typesystem_minimal.xml
@@ -15,20 +15,15 @@
         </conversion-rule>
     </primitive-type>
 
-    <container-type name="std::list" type="list"
-                    opaque-containers="int:StdIntList">
-        <include file-name="list" location="global"/>
-        <conversion-rule>
-            <native-to-target>
-                <insert-template name="shiboken_conversion_cppsequence_to_pylist"/>
-            </native-to-target>
-            <target-to-native>
-                <add-conversion type="PySequence">
-                    <insert-template name="shiboken_conversion_pyiterable_to_cppsequentialcontainer"/>
-                </add-conversion>
-            </target-to-native>
-        </conversion-rule>
-    </container-type>
+    <opaque-container name="std::list" opaque-containers="int:StdIntList"/>
+
+    <opaque-container name="std::vector" opaque-containers="int:StdIntVector"/>
+
+    <opaque-container name="std::array" opaque-containers="int,3:StdIntArray"/>
+
+    <?if c++20?> <!-- FIXME PYSIDE 7: Remove "if" -->
+    <opaque-container name="std::span" opaque-containers="int,3:StdIntSpan3"/>
+    <?endif?>
 
     <object-type name="Obj"/>
     <value-type name="Val">
@@ -47,8 +42,32 @@
             </modify-argument>
         </modify-function>
     </value-type>
+
+    <value-type name="SpanUser">
+        <?if c++20?> <!-- FIXME PYSIDE 7: Remove "if" -->
+        <modify-function signature="getIntSpan3_OpaqueContainer()">
+            <modify-argument index="return">
+                <replace-type modified-type="StdIntSpan3"/>
+            </modify-argument>
+        </modify-function>
+        <?endif?>
+    </value-type>
+
     <value-type name="MinBoolUser"/>
 
+    <value-type name="ContainerUser">
+        <modify-function signature="intVector()">
+            <modify-argument index="return">
+                <replace-type modified-type="StdIntVector"/>
+            </modify-argument>
+        </modify-function>
+        <modify-function signature="intArray()">
+            <modify-argument index="return">
+                <replace-type modified-type="StdIntArray"/>
+            </modify-argument>
+        </modify-function>
+    </value-type>
+
     <!-- Test wrapping of a typedef -->
     <function signature="arrayFuncInt(std::vector&lt;int&gt;)" />
     <!-- Note manual expansion of the typedef -->
diff --git a/sources/shiboken6/tests/minimalbinding/val_test.py b/sources/shiboken6/tests/minimalbinding/val_test.py
index 6403b5f14..b8225a247 100644
--- a/sources/shiboken6/tests/minimalbinding/val_test.py
+++ b/sources/shiboken6/tests/minimalbinding/val_test.py
@@ -92,4 +92,3 @@ class ValTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/otherbinding/CMakeLists.txt b/sources/shiboken6/tests/otherbinding/CMakeLists.txt
index c5e5390fb..2172593d3 100644
--- a/sources/shiboken6/tests/otherbinding/CMakeLists.txt
+++ b/sources/shiboken6/tests/otherbinding/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(other)
 
 set(other_TYPESYSTEM
diff --git a/sources/shiboken6/tests/otherbinding/collector_external_operator_test.py b/sources/shiboken6/tests/otherbinding/collector_external_operator_test.py
index ab9a67345..2ba21653d 100644
--- a/sources/shiboken6/tests/otherbinding/collector_external_operator_test.py
+++ b/sources/shiboken6/tests/otherbinding/collector_external_operator_test.py
@@ -16,6 +16,7 @@ init_paths()
 from sample import Collector, ObjectType
 from other import OtherObjectType
 
+
 class CollectorOtherObjectType(unittest.TestCase):
     '''Test cases for Collector << OtherObjectType'''
 
@@ -33,6 +34,6 @@ class CollectorOtherObjectType(unittest.TestCase):
         collector << obj
         self.assertEqual(collector.items()[0], obj.identifier() * 2)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/otherbinding/conversion_operator_for_class_without_implicit_conversions_test.py b/sources/shiboken6/tests/otherbinding/conversion_operator_for_class_without_implicit_conversions_test.py
index 220cd3c98..bd00b5892 100644
--- a/sources/shiboken6/tests/otherbinding/conversion_operator_for_class_without_implicit_conversions_test.py
+++ b/sources/shiboken6/tests/otherbinding/conversion_operator_for_class_without_implicit_conversions_test.py
@@ -18,8 +18,10 @@ init_paths()
 from sample import NoImplicitConversion
 from other import ExtendsNoImplicitConversion
 
+
 class ConversionOperatorForClassWithoutImplicitConversionsTest(unittest.TestCase):
-    '''Tests calling NoImplicitConversion constructor using a ExtendsNoImplicitConversion parameter.'''
+    '''Tests calling NoImplicitConversion constructor using a
+       ExtendsNoImplicitConversion parameter.'''
 
     def testNoImplicitConversion(self):
         '''Basic test to see if the NoImplicitConversion is Ok.'''
@@ -27,27 +29,33 @@ class ConversionOperatorForClassWithoutImplicitConversionsTest(unittest.TestCase
         # NoImplicitConversion.receivesNoImplicitConversionByValue(NoImplicitConversion)
         self.assertEqual(obj.objId(), NoImplicitConversion.receivesNoImplicitConversionByValue(obj))
         # NoImplicitConversion.receivesNoImplicitConversionByPointer(NoImplicitConversion*)
-        self.assertEqual(obj.objId(), NoImplicitConversion.receivesNoImplicitConversionByPointer(obj))
+        self.assertEqual(obj.objId(),
+                         NoImplicitConversion.receivesNoImplicitConversionByPointer(obj))
         # NoImplicitConversion.receivesNoImplicitConversionByReference(NoImplicitConversion&)
-        self.assertEqual(obj.objId(), NoImplicitConversion.receivesNoImplicitConversionByReference(obj))
+        self.assertEqual(obj.objId(),
+                         NoImplicitConversion.receivesNoImplicitConversionByReference(obj))
 
     def testPassingExtendsNoImplicitConversionAsNoImplicitConversionByValue(self):
-        '''Gives an ExtendsNoImplicitConversion object to a function expecting a NoImplicitConversion, passing by value.'''
+        '''Gives an ExtendsNoImplicitConversion object to a function expecting a
+           NoImplicitConversion, passing by value.'''
         obj = ExtendsNoImplicitConversion(123)
         self.assertEqual(obj.objId(), NoImplicitConversion.receivesNoImplicitConversionByValue(obj))
 
     def testPassingExtendsNoImplicitConversionAsNoImplicitConversionByReference(self):
-        '''Gives an ExtendsNoImplicitConversion object to a function expecting a NoImplicitConversion, passing by reference.'''
+        '''Gives an ExtendsNoImplicitConversion object to a function expecting a
+           NoImplicitConversion, passing by reference.'''
         obj = ExtendsNoImplicitConversion(123)
-        self.assertEqual(obj.objId(), NoImplicitConversion.receivesNoImplicitConversionByReference(obj))
+        self.assertEqual(obj.objId(),
+                         NoImplicitConversion.receivesNoImplicitConversionByReference(obj))
 
     def testPassingExtendsNoImplicitConversionAsNoImplicitConversionByPointer(self):
-        '''Gives an ExtendsNoImplicitConversion object to a function expecting a NoImplicitConversion, passing by pointer.
-           This should not be accepted, since pointers should not be converted.'''
+        '''Gives an ExtendsNoImplicitConversion object to a function expecting
+           a NoImplicitConversion, passing by pointer. This should not be
+           accepted, since pointers should not be converted.'''
         obj = ExtendsNoImplicitConversion(123)
-        self.assertRaises(TypeError, NoImplicitConversion.receivesNoImplicitConversionByPointer, obj)
+        self.assertRaises(TypeError,
+                          NoImplicitConversion.receivesNoImplicitConversionByPointer, obj)
 
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/otherbinding/extended_multiply_operator_test.py b/sources/shiboken6/tests/otherbinding/extended_multiply_operator_test.py
index 169f5259d..abbef6231 100644
--- a/sources/shiboken6/tests/otherbinding/extended_multiply_operator_test.py
+++ b/sources/shiboken6/tests/otherbinding/extended_multiply_operator_test.py
@@ -16,6 +16,7 @@ init_paths()
 from sample import Point
 from other import Number
 
+
 class PointOperationsWithNumber(unittest.TestCase):
     '''Test cases for libsample's Point multiply operator defined in libother module.'''
 
@@ -39,6 +40,6 @@ class PointOperationsWithNumber(unittest.TestCase):
         num = Number(11)
         self.assertEqual(pt * num.value(), pt * 11)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/otherbinding/module_reload_test.py b/sources/shiboken6/tests/otherbinding/module_reload_test.py
index 5be2b4191..bde2f5236 100644
--- a/sources/shiboken6/tests/otherbinding/module_reload_test.py
+++ b/sources/shiboken6/tests/otherbinding/module_reload_test.py
@@ -21,6 +21,7 @@ dst = workdir / 'test_module.py'
 shutil.copyfile(src, dst)
 sys.path.append(os.fspath(workdir))
 
+
 class TestModuleReloading(unittest.TestCase):
 
     def testModuleReloading(self):
@@ -32,5 +33,6 @@ class TestModuleReloading(unittest.TestCase):
             reload(test_module)
             self.assertFalse(oldObject is test_module.obj)
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/sources/shiboken6/tests/otherbinding/new_ctor_operator_test.py b/sources/shiboken6/tests/otherbinding/new_ctor_operator_test.py
index 5e3536c93..d6c356436 100644
--- a/sources/shiboken6/tests/otherbinding/new_ctor_operator_test.py
+++ b/sources/shiboken6/tests/otherbinding/new_ctor_operator_test.py
@@ -2,7 +2,8 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-'''Tests calling Str constructor using a Number parameter, being that number defines a cast operator to Str.'''
+'''Tests calling Str constructor using a Number parameter, being that number defines
+   a cast operator to Str.'''
 
 import os
 import sys
@@ -16,8 +17,10 @@ init_paths()
 from sample import Str
 from other import Number
 
+
 class NewCtorOperatorTest(unittest.TestCase):
-    '''Tests calling Str constructor using a Number parameter, being that number defines a cast operator to Str.'''
+    '''Tests calling Str constructor using a Number parameter, being that number
+       defines a cast operator to Str.'''
 
     def testNumber(self):
         '''Basic test to see if the Number class is Ok.'''
@@ -29,8 +32,8 @@ class NewCtorOperatorTest(unittest.TestCase):
         '''Try to build a Str from 'sample' module with a Number argument from 'other' module.'''
         value = 123
         num = Number(value)
-        string = Str(num)
+        string = Str(num)  # noqa: F841
+
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/otherbinding/objtypehashes_test.py b/sources/shiboken6/tests/otherbinding/objtypehashes_test.py
index d2c441058..d2cd7de5b 100644
--- a/sources/shiboken6/tests/otherbinding/objtypehashes_test.py
+++ b/sources/shiboken6/tests/otherbinding/objtypehashes_test.py
@@ -9,10 +9,10 @@ from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
-from sample import *
-from other import *
+from sample import HandleHolder
 from shiboken6 import Shiboken
 
+
 class TestHashFuncs (unittest.TestCase):
 
     def testIt(self):
@@ -30,6 +30,5 @@ class TestHashFuncs (unittest.TestCase):
         self.assertEqual(hash1_2, hash1)
 
 
-
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/otherbinding/otherderived_test.py b/sources/shiboken6/tests/otherbinding/otherderived_test.py
index 1b876e1ed..459f474f1 100644
--- a/sources/shiboken6/tests/otherbinding/otherderived_test.py
+++ b/sources/shiboken6/tests/otherbinding/otherderived_test.py
@@ -17,6 +17,7 @@ init_paths()
 from sample import Abstract, Derived
 from other import OtherDerived, Number
 
+
 class Multiple(Derived, Number):
     def __init__(self):
         Derived.__init__(self, 42)
@@ -25,6 +26,7 @@ class Multiple(Derived, Number):
     def testCall(self):
         return True
 
+
 class OtherDeviant(OtherDerived):
     def __init__(self):
         OtherDerived.__init__(self)
@@ -40,6 +42,7 @@ class OtherDeviant(OtherDerived):
     def className(self):
         return 'OtherDeviant'
 
+
 class MultipleTest(unittest.TestCase):
     '''Test case for Multiple derived class'''
 
@@ -58,6 +61,7 @@ class MultipleTest(unittest.TestCase):
         self.assertTrue(o.value(), 42)
         self.assertTrue(o.testCall())
 
+
 class OtherDerivedTest(unittest.TestCase):
     '''Test case for OtherDerived class'''
 
@@ -68,13 +72,15 @@ class OtherDerivedTest(unittest.TestCase):
         self.assertTrue(inherited_methods.issubset(dir(OtherDerived)))
 
     def testReimplementedPureVirtualMethodCall(self):
-        '''Test if a Python override of a implemented pure virtual method is correctly called from C++.'''
+        '''Test if a Python override of a implemented pure virtual method is
+           correctly called from C++.'''
         d = OtherDeviant()
         d.callPureVirtual()
         self.assertTrue(d.pure_virtual_called)
 
     def testReimplementedVirtualMethodCall(self):
-        '''Test if a Python override of a reimplemented virtual method is correctly called from C++.'''
+        '''Test if a Python override of a reimplemented virtual method is
+           correctly called from C++.'''
         d = OtherDeviant()
         d.callUnpureVirtual()
         self.assertTrue(d.unpure_virtual_called)
@@ -86,7 +92,8 @@ class OtherDerivedTest(unittest.TestCase):
         self.assertEqual(d.getClassName(), 'OtherDerived')
 
     def testReimplementedVirtualMethodCallReturningString(self):
-        '''Test if a Python override of a reimplemented virtual method is correctly called from C++.'''
+        '''Test if a Python override of a reimplemented virtual method is
+           correctly called from C++.'''
         d = OtherDeviant()
         self.assertEqual(d.className(), 'OtherDeviant')
         self.assertEqual(d.getClassName(), 'OtherDeviant')
@@ -97,6 +104,6 @@ class OtherDerivedTest(unittest.TestCase):
         d = OtherDerived(objId)
         self.assertEqual(Abstract.getObjectId(d), objId)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/otherbinding/othertypesystypedef_test.py b/sources/shiboken6/tests/otherbinding/othertypesystypedef_test.py
index 9ac2456c0..198c71693 100644
--- a/sources/shiboken6/tests/otherbinding/othertypesystypedef_test.py
+++ b/sources/shiboken6/tests/otherbinding/othertypesystypedef_test.py
@@ -13,8 +13,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from other import (OtherValueWithUnitUser, ValueWithUnitIntInch,
-                   ValueWithUnitIntMillimeter)
+from other import (OtherValueWithUnitUser, ValueWithUnitIntMillimeter)
 from sample import (ValueWithUnitDoubleMillimeter)
 
 
diff --git a/sources/shiboken6/tests/otherbinding/signature_test.py b/sources/shiboken6/tests/otherbinding/signature_test.py
index 93f080e6d..8db3e566b 100644
--- a/sources/shiboken6/tests/otherbinding/signature_test.py
+++ b/sources/shiboken6/tests/otherbinding/signature_test.py
@@ -16,8 +16,6 @@ init_paths()
 from other import OtherObjectType
 from shiboken_test_helper import objectFullname
 
-from shiboken6 import Shiboken
-
 from shibokensupport.signature import get_signature
 
 
@@ -29,7 +27,7 @@ class SignatureTest(unittest.TestCase):
     def testNamespaceFromOtherModule(self):
         argType = get_signature(OtherObjectType.enumAsInt).parameters["value"].annotation
         self.assertEqual(objectFullname(argType),
-            "sample.SampleNamespace.SomeClass.PublicScopedEnum")
+                         "sample.SampleNamespace.SomeClass.PublicScopedEnum")
 
 
 if __name__ == '__main__':
diff --git a/sources/shiboken6/tests/otherbinding/smartptr_test.py b/sources/shiboken6/tests/otherbinding/smartptr_test.py
index 6479e6337..fd5c7fa09 100644
--- a/sources/shiboken6/tests/otherbinding/smartptr_test.py
+++ b/sources/shiboken6/tests/otherbinding/smartptr_test.py
@@ -13,8 +13,6 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from smart import Integer
-from sample import Str
 from other import SmartPtrTester
 
 
diff --git a/sources/shiboken6/tests/otherbinding/star_import_test.py b/sources/shiboken6/tests/otherbinding/star_import_test.py
new file mode 100644
index 000000000..4b5f1d270
--- /dev/null
+++ b/sources/shiboken6/tests/otherbinding/star_import_test.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+"""PYSIDE-2404: Test whether star imports work as they require special handling
+   by the lazy initialization."""
+
+import os
+import sys
+import unittest
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from shiboken_paths import init_paths
+init_paths()
+
+SHIBOKEN_NAME = "shiboken6.Shiboken"
+MINIMAL_NAME = "minimal"
+OTHER_NAME = "other"
+
+shiboken_loaded = 1 if sys.modules.get(SHIBOKEN_NAME) else 0
+minimal_loaded = 1 if sys.modules.get(MINIMAL_NAME) else 0
+other_loaded = 1 if sys.modules.get(OTHER_NAME) else 0
+
+from minimal import *       # noqa: F403
+
+shiboken_loaded += 2 if sys.modules.get(SHIBOKEN_NAME) else 0
+minimal_loaded += 2 if sys.modules.get(MINIMAL_NAME) else 0
+other_loaded += 2 if sys.modules.get(OTHER_NAME) else 0
+
+from other import Number    # noqa: F403
+from other import *         # noqa: F403
+
+shiboken_loaded += 4 if sys.modules.get(SHIBOKEN_NAME) else 0
+minimal_loaded += 4 if sys.modules.get(MINIMAL_NAME) else 0
+other_loaded = +4 if sys.modules.get(OTHER_NAME) else 0
+
+import shiboken6.Shiboken   # noqa: F401 F403
+
+shiboken_loaded += 8 if sys.modules.get(SHIBOKEN_NAME) else 0
+
+
+class ValTest(unittest.TestCase):
+
+    def test(self):
+        val_id = 123
+        val = Val(val_id)  # noqa: F405
+        self.assertEqual(val.valId(), val_id)
+
+
+class Simple(Number):
+
+    def __init__(self):
+        Number.__init__(self, 42)
+
+
+class OtherTest(unittest.TestCase):
+
+    def testConstructor(self):
+        o = Simple()
+        self.assertTrue(isinstance(o, Number))
+
+
+class StarImportTest(unittest.TestCase):
+    """
+    This test is meant for Lazy Init.
+    We explicitly choose modules which are able to lazy load.
+
+    The ValTest:
+    ------------
+    We load something with `import *`.
+    There is no module from our known ones imported.
+    This means we need stack introspection to find out that this was
+    a star import and we must disable lazyness.
+
+    The OtherTest:
+    --------------
+    We load something normally that should be lazy.
+    After that, we follow with a star import.
+    Now the stack introspection does not work, because the loading is
+    cached. The first import did a lazy load. The following star import
+    needs to undo the lazyness. But now we have a redirected import.
+
+    All tests simply check if the objects are real and not just names.
+    The <module>_loaded tests prevend upcoming internal dependencies.
+
+    To make sure that Shiboken is really not involved, it is checked
+    and really imported afterwards (ensuring nothing is misspelled).
+    """
+
+    def testStar(self):
+        self.assertEqual(other_loaded, 4)
+        self.assertEqual(minimal_loaded, 6)
+        self.assertEqual(shiboken_loaded, 14)
+        # Interesting effect: Did not expect that shiboken is loaded at all.
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/shiboken6/tests/otherbinding/test_module_template.py b/sources/shiboken6/tests/otherbinding/test_module_template.py
index 183ba9fe5..36ab43ae3 100644
--- a/sources/shiboken6/tests/otherbinding/test_module_template.py
+++ b/sources/shiboken6/tests/otherbinding/test_module_template.py
@@ -1,13 +1,22 @@
 # 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 other import *
-from sample import *
+import os
+import sys
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from shiboken_paths import init_paths
+init_paths()
+
+from other import OtherObjectType
+from sample import ObjectType
 
 
 class MyObjectType(ObjectType):
     pass
 
+
 class MyOtherObjectType(OtherObjectType):
     value = 10
 
diff --git a/sources/shiboken6/tests/otherbinding/typediscovery_test.py b/sources/shiboken6/tests/otherbinding/typediscovery_test.py
index 51fc7c01b..39dc5cf0f 100644
--- a/sources/shiboken6/tests/otherbinding/typediscovery_test.py
+++ b/sources/shiboken6/tests/otherbinding/typediscovery_test.py
@@ -13,9 +13,11 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import Abstract, Base1, Derived, MDerived1, MDerived3, SonOfMDerived1
+from sample import (Abstract, Base1, Derived,
+                    MDerived1, SonOfMDerived1, MDerived3)
 from other import OtherMultipleDerived
 
+
 class TypeDiscoveryTest(unittest.TestCase):
 
     def testPureVirtualsOfImpossibleTypeDiscovery(self):
@@ -29,18 +31,23 @@ class TypeDiscoveryTest(unittest.TestCase):
         self.assertEqual(type(a), Derived)
 
     def testMultipleInheritance(self):
-        obj = OtherMultipleDerived.createObject("Base1");
+        obj = OtherMultipleDerived.createObject("Base1")
         self.assertEqual(type(obj), Base1)
-        # PYSIDE-868: In case of multiple inheritance, a factory
+        # PYSIDE-868: In case of single line direct inheritance,
+        # a factory function will return the class wrapper
+        # of the derived class.
+        obj = OtherMultipleDerived.createObject("MDerived1")
+        self.assertEqual(type(obj), MDerived1)
+        obj = OtherMultipleDerived.createObject("SonOfMDerived1")
+        self.assertEqual(type(obj), SonOfMDerived1)
+        obj = OtherMultipleDerived.createObject("MDerived3")
+        self.assertEqual(type(obj), MDerived3)
+        # PYSIDE-868: OtherMultipleDerived inherits
+        # OtherBase, Base1. In this case, a factory
         # function will return the base class wrapper.
-        obj = OtherMultipleDerived.createObject("MDerived1");
-        self.assertEqual(type(obj), Base1)
-        obj = OtherMultipleDerived.createObject("SonOfMDerived1");
-        self.assertEqual(type(obj), Base1)
-        obj = OtherMultipleDerived.createObject("MDerived3");
-        self.assertEqual(type(obj), Base1)
-        obj = OtherMultipleDerived.createObject("OtherMultipleDerived");
+        obj = OtherMultipleDerived.createObject("OtherMultipleDerived")
         self.assertEqual(type(obj), Base1)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/otherbinding/typesystem_other.xml b/sources/shiboken6/tests/otherbinding/typesystem_other.xml
index 4081548fc..ade1c8bad 100644
--- a/sources/shiboken6/tests/otherbinding/typesystem_other.xml
+++ b/sources/shiboken6/tests/otherbinding/typesystem_other.xml
@@ -17,8 +17,4 @@
     <typedef-type name="ValueWithUnitIntInch" source="ValueWithUnit&lt;int,LengthUnit::Inch&gt;"/>
     <typedef-type name="ValueWithUnitIntMillimeter" source="ValueWithUnit&lt;int,LengthUnit::Millimeter&gt;"/>
     <value-type name="OtherValueWithUnitUser"/>
-
-    <suppress-warning text="signature 'operator!=(ByteArray,const char*)' for function modification in 'ByteArray' not found." />
-    <suppress-warning text="signature 'operator+(ByteArray,const char*)' for function modification in 'ByteArray' not found." />
-    <suppress-warning text="signature 'operator==(ByteArray,const char*)' for function modification in 'ByteArray' not found." />
 </typesystem>
diff --git a/sources/shiboken6/tests/otherbinding/usersprimitivefromothermodule_test.py b/sources/shiboken6/tests/otherbinding/usersprimitivefromothermodule_test.py
index b464fa566..15a988326 100644
--- a/sources/shiboken6/tests/otherbinding/usersprimitivefromothermodule_test.py
+++ b/sources/shiboken6/tests/otherbinding/usersprimitivefromothermodule_test.py
@@ -14,6 +14,7 @@ from shiboken_paths import init_paths
 init_paths()
 from other import Number
 
+
 class UserDefinedPrimitiveTypeFromRequiredModuleTest(unittest.TestCase):
 
     def testUsersPrimitiveFromRequiredModuleAsArgument(self):
@@ -28,5 +29,6 @@ class UserDefinedPrimitiveTypeFromRequiredModuleTest(unittest.TestCase):
         cpx = number.toComplex()
         self.assertEqual(number.value(), int(cpx.real))
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/otherbinding/wrongctor_test.py b/sources/shiboken6/tests/otherbinding/wrongctor_test.py
index 9aacfa9ac..b9251b428 100644
--- a/sources/shiboken6/tests/otherbinding/wrongctor_test.py
+++ b/sources/shiboken6/tests/otherbinding/wrongctor_test.py
@@ -10,17 +10,19 @@ from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
-from sample import *
-from other import *
+from sample import Abstract, ObjectType
+from other import OtherDerived
+
 
 class Foo(OtherDerived):
     def __init__(self):
-        Abstract.__init__(self, 2) # this should raise an exception
+        Abstract.__init__(self, 2)  # this should raise an exception
+
 
 class Foo2(ObjectType, OtherDerived):
     def __init__(self):
         ObjectType.__init__(self)
-        Abstract.__init__(self, 2) # this should raise an exception
+        Abstract.__init__(self, 2)  # this should raise an exception
 
 
 class WrongCtorTest(unittest.TestCase):
diff --git a/sources/shiboken6/tests/qtxmltosphinx/CMakeLists.txt b/sources/shiboken6/tests/qtxmltosphinx/CMakeLists.txt
index ff9207350..11b22f038 100644
--- a/sources/shiboken6/tests/qtxmltosphinx/CMakeLists.txt
+++ b/sources/shiboken6/tests/qtxmltosphinx/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)
 
 # Standalone-buildable
diff --git a/sources/shiboken6/tests/qtxmltosphinx/main.cpp b/sources/shiboken6/tests/qtxmltosphinx/main.cpp
index 27aaee7d1..5b0624376 100644
--- a/sources/shiboken6/tests/qtxmltosphinx/main.cpp
+++ b/sources/shiboken6/tests/qtxmltosphinx/main.cpp
@@ -40,6 +40,7 @@ public:
                                     const QString &) const override;
     const QLoggingCategory &loggingCategory() const override;
     QtXmlToSphinxLink resolveLink(const QtXmlToSphinxLink &link) const override;
+    Image resolveImage(const QString &href, const QString &) const;
 };
 
 // QtXmlToSphinxDocGeneratorInterface
@@ -63,11 +64,18 @@ const QLoggingCategory &QtXmlToSphinxDocGenerator::loggingCategory() const
     return lcQtXmlToSphinx();
 }
 
-QtXmlToSphinxLink QtXmlToSphinxDocGenerator::resolveLink(const QtXmlToSphinxLink &link) const
+QtXmlToSphinxLink
+    QtXmlToSphinxDocGenerator::resolveLink(const QtXmlToSphinxLink &link) const
 {
     return link;
 }
 
+QtXmlToSphinxDocGeneratorInterface::Image
+    QtXmlToSphinxDocGenerator::resolveImage(const QString &href, const QString &) const
+{
+    return {href, href};
+}
+
 static bool run(const QString &fileName)
 {
     QtXmlToSphinxDocGenerator generator;
diff --git a/sources/shiboken6/tests/qtxmltosphinxtest/CMakeLists.txt b/sources/shiboken6/tests/qtxmltosphinxtest/CMakeLists.txt
index 7b3f354ee..25074e716 100644
--- a/sources/shiboken6/tests/qtxmltosphinxtest/CMakeLists.txt
+++ b/sources/shiboken6/tests/qtxmltosphinxtest/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)
 
 project(qtxmltosphinxtest)
diff --git a/sources/shiboken6/tests/qtxmltosphinxtest/qtxmltosphinxtest.cpp b/sources/shiboken6/tests/qtxmltosphinxtest/qtxmltosphinxtest.cpp
index e30033ae7..3ba77196f 100644
--- a/sources/shiboken6/tests/qtxmltosphinxtest/qtxmltosphinxtest.cpp
+++ b/sources/shiboken6/tests/qtxmltosphinxtest/qtxmltosphinxtest.cpp
@@ -5,9 +5,12 @@
 #include "qtxmltosphinx.h"
 #include <QtTest/QTest>
 
+#include <QtCore/QBuffer>
 #include <QtCore/QDebug>
 #include <QtCore/QLoggingCategory>
 
+using namespace Qt::StringLiterals;
+
 Q_LOGGING_CATEGORY(lcQtXmlToSphinxTest, "qt.sphinxtabletest");
 
 // QtXmlToSphinxDocGeneratorInterface
@@ -36,6 +39,12 @@ QtXmlToSphinxLink QtXmlToSphinxTest::resolveLink(const QtXmlToSphinxLink &link)
     return link;
 }
 
+QtXmlToSphinxDocGeneratorInterface::Image
+    QtXmlToSphinxTest::resolveImage(const QString &href, const QString &) const
+{
+    return {href, href};
+}
+
 QString QtXmlToSphinxTest::transformXml(const QString &xml) const
 {
     return QtXmlToSphinx(this, m_parameters, xml).result();
@@ -271,6 +280,43 @@ void QtXmlToSphinxTest::testTable_data()
     QTest::newRow("testRowSpan2")
         << QString::fromLatin1(xml) << QString::fromLatin1(expected);
 
+    // testNestedList
+    xml = R"(<table>
+    <row>
+        <item>
+            <list type="bullet">
+                <item>
+                    <para>I11</para>
+                </item>
+                <item>
+                    <para>I21</para>
+                </item>
+            </list>
+        </item>
+        <item>
+            <list type="bullet">
+                <item>
+                    <para>I12</para>
+                </item>
+                <item>
+                    <para>I22</para>
+                </item>
+            </list>
+        </item>
+    </row>
+</table>)";
+
+    expected = R"(
+    +---------+---------+
+    |    * I11|    * I12|
+    |    * I21|    * I22|
+    +---------+---------+
+
+)";
+
+    QTest::newRow("testNestedList")
+        << QString::fromLatin1(xml) << QString::fromLatin1(expected);
+
     // testBrokenTable
     xml = R"(<table>
     <header>
@@ -344,7 +390,7 @@ void QtXmlToSphinxTest::testTable()
     QCOMPARE(actual, expected);
 }
 
-using TablePtr = QSharedPointer<QtXmlToSphinx::Table>;
+using TablePtr = std::shared_ptr<QtXmlToSphinx::Table>;
 
 Q_DECLARE_METATYPE(TablePtr);
 
@@ -421,4 +467,51 @@ void QtXmlToSphinxTest::testTableFormattingIoDevice()
     QCOMPARE(actual, expected);
 }
 
+void QtXmlToSphinxTest::testSnippetExtraction_data()
+{
+    QTest::addColumn<QByteArray>("file");
+    QTest::addColumn<QLatin1StringView>("id");
+    QTest::addColumn<QString>("expected");
+
+    const char *fileCpp = R"(bla
+// ![snip1]
+snip1_line1
+// ![snip1] // ![snip2]
+snip2_line1
+snip2_line2
+// ![snip2] // ![snip3]
+)";
+
+    constexpr auto id = "snip2"_L1;
+    const QString expected  = uR"(snip2_line1
+snip2_line2
+)"_s;
+
+    const char *filePython = R"(bla
+# ![snip1]
+snip1_line1
+# ![snip1] # ![snip2]
+snip2_line1
+snip2_line2
+# ![snip2] # ![snip3]
+)";
+
+    QTest::newRow("c++") << QByteArray(fileCpp) << id << expected;
+    QTest::newRow("Python") << QByteArray(filePython) << id << expected;
+}
+
+void QtXmlToSphinxTest::testSnippetExtraction()
+{
+    QFETCH(QByteArray, file);
+    QFETCH(QLatin1StringView, id);
+    QFETCH(QString, expected);
+
+    QBuffer buffer(&file);
+    QVERIFY(buffer.open(QIODevice::ReadOnly));
+    QString errorMessage;
+    QString actual = QtXmlToSphinx::readSnippet(buffer, id, &errorMessage);
+    QVERIFY2(errorMessage.isEmpty(), qPrintable(errorMessage));
+    QCOMPARE(actual, expected);
+}
+
 QTEST_APPLESS_MAIN( QtXmlToSphinxTest)
diff --git a/sources/shiboken6/tests/qtxmltosphinxtest/qtxmltosphinxtest.h b/sources/shiboken6/tests/qtxmltosphinxtest/qtxmltosphinxtest.h
index 1c46789d8..5108ef452 100644
--- a/sources/shiboken6/tests/qtxmltosphinxtest/qtxmltosphinxtest.h
+++ b/sources/shiboken6/tests/qtxmltosphinxtest/qtxmltosphinxtest.h
@@ -19,6 +19,7 @@ public:
                                     const QString &) const override;
     const QLoggingCategory &loggingCategory() const override;
     QtXmlToSphinxLink resolveLink(const QtXmlToSphinxLink &link) const override;
+    Image resolveImage(const QString &href, const QString &context) const override;
 
 private slots:
     void testTable_data();
@@ -27,6 +28,8 @@ private slots:
     void testTableFormatting();
     void testTableFormattingIoDevice_data();
     void testTableFormattingIoDevice();
+    void testSnippetExtraction_data();
+    void testSnippetExtraction();
 
 private:
     QString transformXml(const QString &xml) const;
diff --git a/sources/shiboken6/tests/samplebinding/CMakeLists.txt b/sources/shiboken6/tests/samplebinding/CMakeLists.txt
index 44b576cca..fc812feb8 100644
--- a/sources/shiboken6/tests/samplebinding/CMakeLists.txt
+++ b/sources/shiboken6/tests/samplebinding/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(sample)
 
 set(sample_TYPESYSTEM
@@ -113,6 +116,7 @@ ${CMAKE_CURRENT_BINARY_DIR}/sample/samplenamespace_someclass_someinnerclass_wrap
 ${CMAKE_CURRENT_BINARY_DIR}/sample/samplenamespace_someclass_someotherinnerclass_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/sample/samplenamespace_someclass_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/sample/samplenamespace_derivedfromnamespace_wrapper.cpp
+${CMAKE_CURRENT_BINARY_DIR}/sample/stdcomplex_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/sample/simplefile_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/sample/size_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/sample/sizef_wrapper.cpp
diff --git a/sources/shiboken6/tests/samplebinding/__del___test.py b/sources/shiboken6/tests/samplebinding/__del___test.py
index 2d38b24d7..456886614 100644
--- a/sources/shiboken6/tests/samplebinding/__del___test.py
+++ b/sources/shiboken6/tests/samplebinding/__del___test.py
@@ -16,11 +16,13 @@ import sample
 
 delCalled = False
 
+
 class MyObject(sample.ObjectType):
     def __del__(self):
         global delCalled
         delCalled = True
 
+
 class TestDel(unittest.TestCase):
     def testIt(self):
         a = MyObject()
@@ -29,6 +31,6 @@ class TestDel(unittest.TestCase):
         gc.collect()
         self.assertTrue(delCalled)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/abstract_test.py b/sources/shiboken6/tests/samplebinding/abstract_test.py
index 252541af1..89e87be1d 100644
--- a/sources/shiboken6/tests/samplebinding/abstract_test.py
+++ b/sources/shiboken6/tests/samplebinding/abstract_test.py
@@ -15,10 +15,12 @@ init_paths()
 
 from sample import Abstract
 
+
 class Incomplete(Abstract):
     def __init__(self):
         Abstract.__init__(self)
 
+
 class Concrete(Abstract):
     def __init__(self):
         Abstract.__init__(self)
@@ -60,12 +62,7 @@ class AbstractTest(unittest.TestCase):
         # Python and calling it from C++ is undefined until it's decided how to
         # cast the Python data types to void pointers
         c = Concrete()
-        self.assertEqual(c.pureVirtualReturningVoidPtr(),42)
-
-    def testReimplementedVirtualMethodCall(self):
-        '''Test if instanciation of an abstract class raises the correct exception.'''
-        i = Concrete()
-        self.assertRaises(NotImplementedError, i.callPureVirtual)
+        self.assertEqual(c.pureVirtualReturningVoidPtr(), 42)
 
     def testReimplementedVirtualMethodCall(self):
         '''Test if a Python override of a virtual method is correctly called from C++.'''
@@ -85,6 +82,6 @@ class AbstractTest(unittest.TestCase):
         c.callVirtualGettingEnum(Abstract.Short)
         self.assertTrue(c.virtual_getting_enum)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/addedfunction_test.py b/sources/shiboken6/tests/samplebinding/addedfunction_test.py
index 879bba7f2..0b5680143 100644
--- a/sources/shiboken6/tests/samplebinding/addedfunction_test.py
+++ b/sources/shiboken6/tests/samplebinding/addedfunction_test.py
@@ -14,6 +14,7 @@ from shiboken_paths import init_paths
 init_paths()
 from sample import SampleNamespace, ObjectType, Point
 
+
 class TestAddedFunctionsWithSimilarTypes(unittest.TestCase):
     '''Adds new signatures very similar to already existing ones.'''
 
@@ -38,5 +39,6 @@ class TestAddedFunctionsWithSimilarTypes(unittest.TestCase):
         control = len(obj.objectName())
         self.assertEqual(SampleNamespace.passReferenceToObjectType(obj), control)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/addedfunction_with_container_args_test.py b/sources/shiboken6/tests/samplebinding/addedfunction_with_container_args_test.py
index 3a570ccfd..2a739033b 100644
--- a/sources/shiboken6/tests/samplebinding/addedfunction_with_container_args_test.py
+++ b/sources/shiboken6/tests/samplebinding/addedfunction_with_container_args_test.py
@@ -14,18 +14,20 @@ from shiboken_paths import init_paths
 init_paths()
 from sample import sum2d, sumproduct
 
+
 class TestAddedFunctionsWithContainerArgs(unittest.TestCase):
     '''Tests added functions with nested and multi-argument container types.'''
 
     def testNestedContainerType(self):
         '''Test added function with single-argument containers.'''
-        values = [[1,2],[3,4,5],[6]]
+        values = [[1, 2], [3, 4, 5], [6]]
         self.assertEqual(sum2d(values), 21)
 
     def testMultiArgContainerType(self):
         '''Test added function with a two-argument container.'''
-        values = [(1,2),(3,4),(5,6)]
+        values = [(1, 2), (3, 4), (5, 6)]
         self.assertEqual(sumproduct(values), 44)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/argumentmodifications_test.py b/sources/shiboken6/tests/samplebinding/argumentmodifications_test.py
index 8158f89d2..b0ca56a6d 100644
--- a/sources/shiboken6/tests/samplebinding/argumentmodifications_test.py
+++ b/sources/shiboken6/tests/samplebinding/argumentmodifications_test.py
@@ -16,6 +16,7 @@ init_paths()
 
 from sample import Modifications, Point
 
+
 class ArgumentModificationsTest(unittest.TestCase):
     '''Test cases for method arguments modifications performed as described on typesystem.'''
 
@@ -40,7 +41,8 @@ class ArgumentModificationsTest(unittest.TestCase):
 
     def testArgRemoval1(self):
         '''Tests argument removal modifications on Modifications.argRemoval1.'''
-        # void [-> PyObject*] argRemoval1(int, bool, Point = Point(1, 2) [removed], Point = Point(3, 4) [removed], int = 333)
+        # void [-> PyObject*] argRemoval1(int, bool, Point = Point(1, 2) [removed],
+        #      Point = Point(3, 4) [removed], int = 333)
         # code-injection: returns tuple with received parameters plus removed ones
         a0, a1, a2 = 1, True, 2
         self.assertEqual(self.mods.argRemoval1(a0, a1), (a0, a1, Point(1, 2), Point(3, 4), 333))
@@ -51,7 +53,8 @@ class ArgumentModificationsTest(unittest.TestCase):
 
     def testArgRemoval2(self):
         '''Tests argument removal modifications on Modifications.argRemoval2.'''
-        # void [-> PyObject*] argRemoval2(int, bool, Point = Point(1, 2) [removed], Point = Point(3, 4) [removed], int = 333)
+        # void [-> PyObject*] argRemoval2(int, bool, Point = Point(1, 2)
+        #      [removed], Point = Point(3, 4) [removed], int = 333)
         # code-injection: returns tuple with received parameters plus removed ones
         a0, a1, a2 = 1, True, 2
         self.assertEqual(self.mods.argRemoval2(a0, a1), (a0, a1, Point(1, 2), Point(3, 4), 333))
@@ -59,7 +62,8 @@ class ArgumentModificationsTest(unittest.TestCase):
 
     def testArgRemoval3(self):
         '''Tests argument removal modifications on Modifications.argRemoval3.'''
-        # void [-> PyObject*] argRemoval3(int, Point = Point(1, 2) [removed], bool = true, Point = Point(3, 4) [removed], int = 333)
+        # void [-> PyObject*] argRemoval3(int, Point = Point(1, 2) [removed],
+        #      bool = true, Point = Point(3, 4) [removed], int = 333)
         # code-injection: returns tuple with received parameters plus removed ones
         a0, a1, a2 = 1, True, 2
         self.assertEqual(self.mods.argRemoval3(a0), (a0, Point(1, 2), True, Point(3, 4), 333))
@@ -68,7 +72,8 @@ class ArgumentModificationsTest(unittest.TestCase):
 
     def testArgRemoval4(self):
         '''Tests argument removal modifications on Modifications.argRemoval4.'''
-        # void [-> PyObject*] argRemoval4(int, Point [removed, new val = Point(6, 9)], bool, Point = Point(3, 4) [removed], int = 333)
+        # void [-> PyObject*] argRemoval4(int, Point [removed, new val = Point(6, 9)], bool,
+        #      Point = Point(3, 4) [removed], int = 333)
         # code-injection: returns tuple with received parameters plus removed ones
         a0, a1, a2 = 1, True, 2
         self.assertRaises(TypeError, self.mods.argRemoval4, a0)
@@ -88,6 +93,6 @@ class ArgumentModificationsTest(unittest.TestCase):
         # code-injection: returns tuple with received parameters plus removed ones
         self.assertEqual(self.mods.argRemoval5(a0, a1, a2), (200, a0, a1, a2))
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/array_numpy_test.py b/sources/shiboken6/tests/samplebinding/array_numpy_test.py
index ba9194122..0d73bca1c 100644
--- a/sources/shiboken6/tests/samplebinding/array_numpy_test.py
+++ b/sources/shiboken6/tests/samplebinding/array_numpy_test.py
@@ -22,24 +22,26 @@ try:
 except ImportError:
     pass
 
+
 class ArrayTester(unittest.TestCase):
     '''Test case for NumPy arrays.'''
 
     def testIntArray(self):
-        intList = numpy.array([1, 2, 3, 4], dtype = 'int32')
+        intList = numpy.array([1, 2, 3, 4], dtype='int32')
         self.assertEqual(sample.sumIntArray(intList), 10)
 
     def testDoubleArray(self):
-        doubleList = numpy.array([1, 2, 3, 4], dtype = 'double')
+        doubleList = numpy.array([1, 2, 3, 4], dtype='double')
         self.assertEqual(sample.sumDoubleArray(doubleList), 10)
 
     def testIntMatrix(self):
-        intMatrix = numpy.array([[1, 2, 3], [4, 5, 6]], dtype = 'int32')
+        intMatrix = numpy.array([[1, 2, 3], [4, 5, 6]], dtype='int32')
         self.assertEqual(sample.sumIntMatrix(intMatrix), 21)
 
     def testDoubleMatrix(self):
-        doubleMatrix = numpy.array([[1, 2, 3], [4, 5, 6]], dtype = 'double')
+        doubleMatrix = numpy.array([[1, 2, 3], [4, 5, 6]], dtype='double')
         self.assertEqual(sample.sumDoubleMatrix(doubleMatrix), 21)
 
+
 if __name__ == '__main__' and hasNumPy:
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/array_sequence_test.py b/sources/shiboken6/tests/samplebinding/array_sequence_test.py
index cb5cbc49d..ad65d58db 100644
--- a/sources/shiboken6/tests/samplebinding/array_sequence_test.py
+++ b/sources/shiboken6/tests/samplebinding/array_sequence_test.py
@@ -14,6 +14,7 @@ from shiboken_paths import init_paths
 init_paths()
 import sample
 
+
 class ArrayTester(unittest.TestCase):
     '''Test case for arrays.'''
 
@@ -30,5 +31,6 @@ class ArrayTester(unittest.TestCase):
         doubleList = [1.2, 2.3, 3.4, 4.5]
         self.assertEqual(sample.sumDoubleArray(doubleList), 11.4)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/bug_554_test.py b/sources/shiboken6/tests/samplebinding/bug_554_test.py
index 6c4df6399..a7e7a7210 100644
--- a/sources/shiboken6/tests/samplebinding/bug_554_test.py
+++ b/sources/shiboken6/tests/samplebinding/bug_554_test.py
@@ -11,15 +11,15 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import ObjectType
+
 
 class Bug554:
     def crash(self):
         class Crasher(ObjectType):
             pass
 
+
 if __name__ == '__main__':
     bug = Bug554()
     bug.crash()
-
-
diff --git a/sources/shiboken6/tests/samplebinding/bug_704_test.py b/sources/shiboken6/tests/samplebinding/bug_704_test.py
index 6de8fa3ea..c470fe723 100644
--- a/sources/shiboken6/tests/samplebinding/bug_704_test.py
+++ b/sources/shiboken6/tests/samplebinding/bug_704_test.py
@@ -25,13 +25,12 @@ def defineNewStyle():
 
 
 class ObjectTypeTest(unittest.TestCase):
-    '''Test cases to avoid declaring Shiboken classes with multiple inheritance from old style classes.'''
+    '''Test cases to avoid declaring Shiboken classes with multiple inheritance
+       from old style classes.'''
 
     def testObjectTypeNewStype(self):
         defineNewStyle()
 
 
-
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/bytearray_test.py b/sources/shiboken6/tests/samplebinding/bytearray_test.py
index e7c421b96..e51a899fa 100644
--- a/sources/shiboken6/tests/samplebinding/bytearray_test.py
+++ b/sources/shiboken6/tests/samplebinding/bytearray_test.py
@@ -34,7 +34,7 @@ class ByteArrayConcatenationOperatorTest(unittest.TestCase):
 
     def testConcatPythonStringAndByteArray(self):
         # Test concatenation of a Python string with a ByteArray, in this order.
-        concat_python_string_add_qbytearray_worked = True
+        concat_python_string_add_qbytearray_worked = True  # noqa: F841
         ba = ByteArray('foo')
         result = 'bar\x00' + ba
         self.assertEqual(type(result), ByteArray)
@@ -80,14 +80,14 @@ class ByteArrayOperatorAt(unittest.TestCase):
         # ByteArray[x] where x is a valid index (reverse order).
         string = 'abcdefgh'
         obj = ByteArray(string)
-        for i in range(len(string)-1, 0, -1):
+        for i in range(len(string) - 1, 0, -1):
             self.assertEqual(obj[i], bytes(string[i], "UTF8"))
 
     def testOutOfRange(self):
         # ByteArray[x] where x is out of index.
         string = '1234567'
         obj = ByteArray(string)
-        self.assertRaises(IndexError, lambda :obj[len(string)])
+        self.assertRaises(IndexError, lambda: obj[len(string)])
 
     def testNullStrings(self):
         ba = ByteArray('\x00')
diff --git a/sources/shiboken6/tests/samplebinding/child_return_test.py b/sources/shiboken6/tests/samplebinding/child_return_test.py
index 97525bcb8..f0ac70626 100644
--- a/sources/shiboken6/tests/samplebinding/child_return_test.py
+++ b/sources/shiboken6/tests/samplebinding/child_return_test.py
@@ -14,7 +14,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import ObjectType
+
 
 class ReturnOfChildTest(unittest.TestCase):
     '''The BlackBox class has cases of ownership transference between C++ and Python.'''
@@ -37,6 +38,6 @@ class ReturnOfChildTest(unittest.TestCase):
         gc.collect()
         self.assertRaises(RuntimeError, child.objectName)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/class_fields_test.py b/sources/shiboken6/tests/samplebinding/class_fields_test.py
index 9da25e137..1eeb3d446 100644
--- a/sources/shiboken6/tests/samplebinding/class_fields_test.py
+++ b/sources/shiboken6/tests/samplebinding/class_fields_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import Derived, Point, ObjectType
 
+
 class TestAccessingCppFields(unittest.TestCase):
     '''Simple test case for accessing the exposed C++ class fields.'''
 
@@ -36,7 +37,7 @@ class TestAccessingCppFields(unittest.TestCase):
         self.assertEqual(d.primitiveField, int(value))
 
         # attribution with invalid type
-        self.assertRaises(TypeError, lambda : setattr(d, 'primitiveField', None))
+        self.assertRaises(TypeError, lambda: setattr(d, 'primitiveField', None))
 
     def testAccessingRenamedFields(self):
         '''Reads and writes a renamed field.'''
@@ -72,7 +73,7 @@ class TestAccessingCppFields(unittest.TestCase):
         self.assertNotEqual(d.userPrimitiveField, old_value)
 
         # attribution with invalid type
-        self.assertRaises(TypeError, lambda : setattr(d, 'userPrimitiveField', None))
+        self.assertRaises(TypeError, lambda: setattr(d, 'userPrimitiveField', None))
 
     def testAccessingValueTypeField(self):
         '''Reads and writes a value type (in this case a 'Point') field.'''
@@ -80,7 +81,7 @@ class TestAccessingCppFields(unittest.TestCase):
         self.assertEqual(type(d.valueTypeField), Point)
 
         # attribution
-        old_value = d.valueTypeField
+        old_value = d.valueTypeField  # noqa: F841
         new_value = Point(-10, 537)
         d.valueTypeField = new_value
         self.assertEqual(d.valueTypeField, new_value)
@@ -92,7 +93,7 @@ class TestAccessingCppFields(unittest.TestCase):
         self.assertEqual(d.valueTypeField.y(), 20)
 
         # attribution with invalid type
-        self.assertRaises(TypeError, lambda : setattr(d, 'valueTypeField', 123))
+        self.assertRaises(TypeError, lambda: setattr(d, 'valueTypeField', 123))
 
     def testAccessingObjectTypeField(self):
         '''Reads and writes a object type (in this case an 'ObjectType') field.'''
@@ -111,7 +112,7 @@ class TestAccessingCppFields(unittest.TestCase):
         self.assertEqual(d.objectTypeField, value)
 
         # attribution with invalid type
-        self.assertRaises(TypeError, lambda : setattr(d, 'objectTypeField', 123))
+        self.assertRaises(TypeError, lambda: setattr(d, 'objectTypeField', 123))
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCountingAccessingObjectTypeField(self):
@@ -155,7 +156,7 @@ class TestAccessingCppFields(unittest.TestCase):
         # attribution
         old_value = d.bitField
         new_value = 1
-        d.bitField= new_value
+        d.bitField = new_value
         self.assertEqual(d.bitField, new_value)
         self.assertNotEqual(d.bitField, old_value)
 
@@ -165,7 +166,7 @@ class TestAccessingCppFields(unittest.TestCase):
         self.assertEqual(d.bitField, int(value))
 
         # attribution with invalid type
-        self.assertRaises(TypeError, lambda : setattr(d, 'bitField', None))
+        self.assertRaises(TypeError, lambda: setattr(d, 'bitField', None))
 
 
 if __name__ == '__main__':
diff --git a/sources/shiboken6/tests/samplebinding/collector_test.py b/sources/shiboken6/tests/samplebinding/collector_test.py
index 376f91f1c..4caebc62a 100644
--- a/sources/shiboken6/tests/samplebinding/collector_test.py
+++ b/sources/shiboken6/tests/samplebinding/collector_test.py
@@ -33,6 +33,7 @@ class CollectorTest(unittest.TestCase):
         self.assertEqual(collector.size(), 5)
         self.assertEqual(collector.items(), [2, 3, 5, 7, 11])
 
+
 class CollectorExternalOperator(unittest.TestCase):
     '''Test cases for external operators of Collector'''
 
@@ -57,4 +58,3 @@ class CollectorObjectType(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/complex_test.py b/sources/shiboken6/tests/samplebinding/complex_test.py
index 6f0b23b2a..454aff100 100644
--- a/sources/shiboken6/tests/samplebinding/complex_test.py
+++ b/sources/shiboken6/tests/samplebinding/complex_test.py
@@ -16,6 +16,7 @@ init_paths()
 import sample
 from sample import Point
 
+
 class ComplexTest(unittest.TestCase):
     '''Test case for conversions between C++ Complex class to Python complex class'''
 
@@ -47,11 +48,14 @@ class ComplexTest(unittest.TestCase):
 
     def testUsingTuples(self):
         cpx1, cpx2 = (1.2, 3.4), (5.6, 7.8)
-        self.assertEqual(sample.sumComplexPair((cpx1, cpx2)), sample.sumComplexPair((complex(*cpx1), complex(*cpx2))))
+        self.assertEqual(sample.sumComplexPair((cpx1, cpx2)),
+                         sample.sumComplexPair((complex(*cpx1), complex(*cpx2))))
         cpx1, cpx2 = (1, 3), (5, 7)
-        self.assertEqual(sample.sumComplexPair((cpx1, cpx2)), sample.sumComplexPair((complex(*cpx1), complex(*cpx2))))
+        self.assertEqual(sample.sumComplexPair((cpx1, cpx2)),
+                         sample.sumComplexPair((complex(*cpx1), complex(*cpx2))))
         cpx1, cpx2 = (1.2, 3), (5.6, 7)
-        self.assertEqual(sample.sumComplexPair((cpx1, cpx2)), sample.sumComplexPair((complex(*cpx1), complex(*cpx2))))
+        self.assertEqual(sample.sumComplexPair((cpx1, cpx2)),
+                         sample.sumComplexPair((complex(*cpx1), complex(*cpx2))))
         cpx1, cpx2 = (1, 2, 3), (4, 5, 7)
         self.assertRaises(TypeError, sample.sumComplexPair, (cpx1, cpx2))
         cpx1, cpx2 = ('1', '2'), ('4', '5')
@@ -60,4 +64,3 @@ class ComplexTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/conversion_operator_test.py b/sources/shiboken6/tests/samplebinding/conversion_operator_test.py
index f349ae82b..7e76245b1 100644
--- a/sources/shiboken6/tests/samplebinding/conversion_operator_test.py
+++ b/sources/shiboken6/tests/samplebinding/conversion_operator_test.py
@@ -15,11 +15,13 @@ init_paths()
 
 from sample import Time, StrList
 
+
 class ConversionOperatorTest(unittest.TestCase):
     '''Test cases for implicit conversion generated by conversion operator.'''
 
     def testConversionOperator(self):
-        '''Time defined an conversion operator for Str, so passing a Time object to a method expecting a Str should work.'''
+        '''Time defined an conversion operator for Str, so passing a Time object
+           to a method expecting a Str should work.'''
         t = Time(1, 2, 3)
         t_str = t.toString()
         sl = StrList()
@@ -30,6 +32,6 @@ class ConversionOperatorTest(unittest.TestCase):
         self.assertEqual(len(sl), 1)
         self.assertEqual(sl[0], t_str)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/copy_test.py b/sources/shiboken6/tests/samplebinding/copy_test.py
index 0a0533a41..db539d1b9 100644
--- a/sources/shiboken6/tests/samplebinding/copy_test.py
+++ b/sources/shiboken6/tests/samplebinding/copy_test.py
@@ -63,4 +63,3 @@ class PicklingTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/ctorconvrule_test.py b/sources/shiboken6/tests/samplebinding/ctorconvrule_test.py
index 0ad21e35c..5e2695d72 100644
--- a/sources/shiboken6/tests/samplebinding/ctorconvrule_test.py
+++ b/sources/shiboken6/tests/samplebinding/ctorconvrule_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import CtorConvRule
 
+
 class TestCtorConvRule(unittest.TestCase):
     '''Simple test case for CtorConvRule'''
 
@@ -24,6 +25,6 @@ class TestCtorConvRule(unittest.TestCase):
         obj = CtorConvRule(value)
         self.assertEqual(obj.value(), value + 1)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/cyclic_test.py b/sources/shiboken6/tests/samplebinding/cyclic_test.py
index b72e41b19..4e4ae2603 100644
--- a/sources/shiboken6/tests/samplebinding/cyclic_test.py
+++ b/sources/shiboken6/tests/samplebinding/cyclic_test.py
@@ -16,7 +16,6 @@ from sample import ObjectView
 from sample import ObjectModel
 
 
-
 class ObjTest(unittest.TestCase):
 
     def test_cyclic_dependency_withParent(self):
@@ -37,7 +36,7 @@ class ObjTest(unittest.TestCase):
         # turn off automatic garbage collection, to be able to trigger it
         # at the 'right' time
         gc.disable()
-        alive = lambda :sum(isinstance(o, CyclicObject) for o in gc.get_objects() )
+        alive = lambda: sum(isinstance(o, CyclicObject) for o in gc.get_objects())  # noqa: E731
 
         #
         # first proof that the wizard is only destructed by the garbage
@@ -70,7 +69,7 @@ class ObjTest(unittest.TestCase):
         # turn off automatic garbage collection, to be able to trigger it
         # at the 'right' time
         gc.disable()
-        alive = lambda :sum(isinstance(o, CyclicObject) for o in gc.get_objects() )
+        alive = lambda: sum(isinstance(o, CyclicObject) for o in gc.get_objects())  # noqa: E731
 
         #
         # first proof that the wizard is only destructed by the garbage
@@ -85,6 +84,6 @@ class ObjTest(unittest.TestCase):
         gc.collect()
         self.assertFalse(alive())
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/date_test.py b/sources/shiboken6/tests/samplebinding/date_test.py
index a35861c8c..2b6efcf18 100644
--- a/sources/shiboken6/tests/samplebinding/date_test.py
+++ b/sources/shiboken6/tests/samplebinding/date_test.py
@@ -16,6 +16,7 @@ from datetime import date
 
 from sample import SbkDate
 
+
 class DateConversionTest(unittest.TestCase):
 
     def testConstructorWithDateObject(self):
@@ -32,6 +33,6 @@ class DateConversionTest(unittest.TestCase):
         self.assertTrue(cDate.month(), pyDate.month)
         self.assertTrue(cDate.year(), pyDate.year)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/decisor_test.py b/sources/shiboken6/tests/samplebinding/decisor_test.py
index 6c7b4482d..0d39c5f96 100644
--- a/sources/shiboken6/tests/samplebinding/decisor_test.py
+++ b/sources/shiboken6/tests/samplebinding/decisor_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import SampleNamespace, Point, ObjectType, ObjectModel
 
+
 class DecisorTest(unittest.TestCase):
     '''Test cases for the method overload decisor.'''
 
@@ -37,11 +38,15 @@ class DecisorTest(unittest.TestCase):
         '''Call methods overloads that receive parent and inheritor classes' instances.'''
         objecttype = ObjectType()
         objectmodel = ObjectModel()
-        self.assertEqual(ObjectModel.receivesObjectTypeFamily(objecttype), ObjectModel.ObjectTypeCalled)
-        self.assertNotEqual(ObjectModel.receivesObjectTypeFamily(objecttype), ObjectModel.ObjectModelCalled)
-        self.assertEqual(ObjectModel.receivesObjectTypeFamily(objectmodel), ObjectModel.ObjectModelCalled)
-        self.assertNotEqual(ObjectModel.receivesObjectTypeFamily(objectmodel), ObjectModel.ObjectTypeCalled)
+        self.assertEqual(ObjectModel.receivesObjectTypeFamily(objecttype),
+                         ObjectModel.ObjectTypeCalled)
+        self.assertNotEqual(ObjectModel.receivesObjectTypeFamily(objecttype),
+                            ObjectModel.ObjectModelCalled)
+        self.assertEqual(ObjectModel.receivesObjectTypeFamily(objectmodel),
+                         ObjectModel.ObjectModelCalled)
+        self.assertNotEqual(ObjectModel.receivesObjectTypeFamily(objectmodel),
+                            ObjectModel.ObjectTypeCalled)
+
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/delete_test.py b/sources/shiboken6/tests/samplebinding/delete_test.py
index 5a4ee090e..57a792ae2 100644
--- a/sources/shiboken6/tests/samplebinding/delete_test.py
+++ b/sources/shiboken6/tests/samplebinding/delete_test.py
@@ -14,15 +14,15 @@ init_paths()
 import sample
 from shiboken6 import Shiboken
 
+
 class DeleteTest(unittest.TestCase):
     def testNonCppWrapperClassDelete(self):
-        """Would segfault when shiboken.delete called on obj not created from
-        Python """
+        """Would segfault when shiboken.delete called on obj not created from Python."""
         obj = sample.ObjectType()
         child = obj.createChild(None)
         Shiboken.delete(child)
         assert not Shiboken.isValid(child)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/deprecated_test.py b/sources/shiboken6/tests/samplebinding/deprecated_test.py
index 95b07f838..c371df94f 100644
--- a/sources/shiboken6/tests/samplebinding/deprecated_test.py
+++ b/sources/shiboken6/tests/samplebinding/deprecated_test.py
@@ -14,11 +14,13 @@ init_paths()
 
 from sample import ObjectType
 
+
 class TestDeprecatedCall(unittest.TestCase):
     def testCallWithError(self):
         o = ObjectType()
         warnings.simplefilter('error')
         self.assertRaises(DeprecationWarning, o.deprecatedFunction)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/derived_test.py b/sources/shiboken6/tests/samplebinding/derived_test.py
index 7db8e5155..346f29136 100644
--- a/sources/shiboken6/tests/samplebinding/derived_test.py
+++ b/sources/shiboken6/tests/samplebinding/derived_test.py
@@ -16,6 +16,7 @@ init_paths()
 import sample
 from sample import Abstract, Derived, DerivedUsingCt, OverloadedFuncEnum
 
+
 class Deviant(Derived):
     def __init__(self):
         Derived.__init__(self)
@@ -31,6 +32,16 @@ class Deviant(Derived):
     def className(self):
         return 'Deviant'
 
+
+class ImplementVirtualWithOutParameter(Derived):
+    def __init__(self, value):
+        super().__init__()
+        self._value = value
+
+    def virtualWithOutParameter(self):
+        return self._value
+
+
 class DerivedTest(unittest.TestCase):
     '''Test case for Derived class'''
 
@@ -40,23 +51,6 @@ class DerivedTest(unittest.TestCase):
                                  'id_', 'pureVirtual', 'unpureVirtual'])
         self.assertTrue(inherited_methods.issubset(dir(Derived)))
 
-    @unittest.skipIf(sys.pyside63_option_python_enum, "Makes no sense with strict Enums")
-    def testOverloadedMethodCall(self):
-        '''Test if the correct overloaded method is being called.'''
-        derived = Derived()
-
-        result = derived.overloaded(1, 2)
-        self.assertEqual(type(result), OverloadedFuncEnum)
-        self.assertEqual(result, sample.OverloadedFunc_ii)
-
-        result = derived.overloaded(3)
-        self.assertEqual(type(result), OverloadedFuncEnum)
-        self.assertEqual(result, sample.OverloadedFunc_ii)
-
-        result = derived.overloaded(4.4)
-        self.assertEqual(type(result), OverloadedFuncEnum)
-        self.assertEqual(result, sample.OverloadedFunc_d)
-
     def testOtherOverloadedMethodCall(self):
         '''Another test to check overloaded method calling, just to double check.'''
         derived = Derived()
@@ -74,22 +68,23 @@ class DerivedTest(unittest.TestCase):
         derived = Derived()
         result = derived.overloaded(1.1, 2.2)
         self.assertEqual(type(result), OverloadedFuncEnum)
-        if not sys.pyside63_option_python_enum:
-            self.assertEqual(result, sample.OverloadedFunc_ii)
 
     def testOverloadedMethodCallWithWrongNumberOfArguments(self):
-        '''Test if a call to an overloaded method with the wrong number of arguments raises an exception.'''
+        '''Test if a call to an overloaded method with the wrong number of arguments
+           raises an exception.'''
         derived = Derived()
         self.assertRaises(TypeError, derived.otherOverloaded, 1, 2, True)
 
     def testReimplementedPureVirtualMethodCall(self):
-        '''Test if a Python override of a implemented pure virtual method is correctly called from C++.'''
+        '''Test if a Python override of a implemented pure virtual method is
+           correctly called from C++.'''
         d = Deviant()
         d.callPureVirtual()
         self.assertTrue(d.pure_virtual_called)
 
     def testReimplementedVirtualMethodCall(self):
-        '''Test if a Python override of a reimplemented virtual method is correctly called from C++.'''
+        '''Test if a Python override of a reimplemented virtual method is
+           correctly called from C++.'''
         d = Deviant()
         d.callUnpureVirtual()
         self.assertTrue(d.unpure_virtual_called)
@@ -101,7 +96,8 @@ class DerivedTest(unittest.TestCase):
         self.assertEqual(d.getClassName(), 'Derived')
 
     def testReimplementedVirtualMethodCallReturningString(self):
-        '''Test if a Python override of a reimplemented virtual method is correctly called from C++.'''
+        '''Test if a Python override of a reimplemented virtual method is
+           correctly called from C++.'''
         d = Deviant()
         self.assertEqual(d.className(), 'Deviant')
         self.assertEqual(d.getClassName(), 'Deviant')
@@ -125,7 +121,8 @@ class DerivedTest(unittest.TestCase):
         self.assertEqual(Abstract.getObjectId(d), objId)
 
     def testObjectCreationWithParentType(self):
-        '''Derived class creates an instance of itself in C++ and returns it as a pointer to its ancestor Abstract.'''
+        '''Derived class creates an instance of itself in C++ and returns it as
+           a pointer to its ancestor Abstract.'''
         obj = Derived.createObject()
         self.assertEqual(type(obj), Derived)
 
@@ -134,7 +131,13 @@ class DerivedTest(unittest.TestCase):
         obj = DerivedUsingCt(42)
         self.assertEqual(obj.value(), 42)
 
+    def testVirtualWithOutParameter(self):
+        d = Derived()
+        self.assertEqual(d.callVirtualWithOutParameter(), 42)
+
+        d = ImplementVirtualWithOutParameter(1)
+        self.assertEqual(d.callVirtualWithOutParameter(), 1)
+
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/duck_punching_test.py b/sources/shiboken6/tests/samplebinding/duck_punching_test.py
index e1d89e2c0..aa21a0f7e 100644
--- a/sources/shiboken6/tests/samplebinding/duck_punching_test.py
+++ b/sources/shiboken6/tests/samplebinding/duck_punching_test.py
@@ -16,6 +16,7 @@ init_paths()
 
 from sample import VirtualMethods, SimpleFile, Point
 
+
 def MethodTypeCompat(func, instance):
     return types.MethodType(func, instance)
 
@@ -24,10 +25,12 @@ class Duck(VirtualMethods):
     def __init__(self):
         VirtualMethods.__init__(self)
 
+
 class Monkey(SimpleFile):
     def __init__(self, filename):
         SimpleFile.__init__(self, filename)
 
+
 class DuckPunchingTest(unittest.TestCase):
     '''Test case for duck punching (aka "monkey patching").'''
 
@@ -56,7 +59,8 @@ class DuckPunchingTest(unittest.TestCase):
 
         result2 = vm.virtualMethod0(pt, val, cpx, b)
         self.assertEqual(result1, result2)
-        self.assertEqual(result1, VirtualMethods.virtualMethod0(vm, pt, val, cpx, b) * self.multiplier)
+        self.assertEqual(result1,
+                         VirtualMethods.virtualMethod0(vm, pt, val, cpx, b) * self.multiplier)
 
         # This is done to decrease the refcount of the vm object
         # allowing the object wrapper to be deleted before the
@@ -66,7 +70,8 @@ class DuckPunchingTest(unittest.TestCase):
         vm.virtualMethod0 = None
 
     def testMonkeyPatchOnVirtualMethodWithInheritance(self):
-        '''Injects new 'virtualMethod0' on an object that inherits from VirtualMethods and makes C++ call it.'''
+        '''Injects new 'virtualMethod0' on an object that inherits from
+           VirtualMethods and makes C++ call it.'''
         duck = Duck()
         pt, val, cpx, b = Point(1.1, 2.2), 4, complex(3.3, 4.4), True
 
@@ -85,7 +90,8 @@ class DuckPunchingTest(unittest.TestCase):
 
         result2 = duck.virtualMethod0(pt, val, cpx, b)
         self.assertEqual(result1, result2)
-        self.assertEqual(result1, VirtualMethods.virtualMethod0(duck, pt, val, cpx, b) * self.multiplier)
+        self.assertEqual(result1,
+                         VirtualMethods.virtualMethod0(duck, pt, val, cpx, b) * self.multiplier)
 
         duck.virtualMethod0 = None
 
@@ -150,4 +156,3 @@ class DuckPunchingTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/echo_test.py b/sources/shiboken6/tests/samplebinding/echo_test.py
index 567d1452a..f1859260e 100644
--- a/sources/shiboken6/tests/samplebinding/echo_test.py
+++ b/sources/shiboken6/tests/samplebinding/echo_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import Echo
 
+
 class TestEcho(unittest.TestCase):
     '''Simple test case for Echo.echo'''
 
@@ -26,7 +27,8 @@ class TestEcho(unittest.TestCase):
 
     def testCallOperator(self):
         e = Echo()
-        self.assertEqual(e("Hello", 3), "Hello3");
+        self.assertEqual(e("Hello", 3), "Hello3")
+
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/enum_test.py b/sources/shiboken6/tests/samplebinding/enum_test.py
index 90f36a186..276b8d894 100644
--- a/sources/shiboken6/tests/samplebinding/enum_test.py
+++ b/sources/shiboken6/tests/samplebinding/enum_test.py
@@ -13,12 +13,10 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-import shiboken6
 # This is needed after the introduction of BUILD_DIR.
 
 import sample
 from sample import SampleNamespace, ObjectType, Event
-from shibokensupport.signature import get_signature
 
 
 def createTempFile():
@@ -29,22 +27,13 @@ def createTempFile():
 class EnumTest(unittest.TestCase):
     '''Test case for Python representation of C++ enums.'''
 
-    @unittest.skipIf(sys.pyside63_option_python_enum, "test not suitable for Python enum")
-    def testEnumRepr(self):
-        enum = SampleNamespace.Option(1)
-        self.assertEqual(eval(repr(enum)), enum)
-
-        enum = SampleNamespace.Option(999)
-        self.assertEqual(eval(repr(enum)), enum)
-
     def testHashability(self):
         self.assertEqual(hash(SampleNamespace.TwoIn), hash(SampleNamespace.TwoOut))
         self.assertNotEqual(hash(SampleNamespace.TwoIn), hash(SampleNamespace.OneIn))
 
     def testEnumValuesInsideEnum(self):
         '''Enum values should be accessible inside the enum as well as outside.'''
-        for value_name in (SampleNamespace.Option.__members__ if sys.pyside63_option_python_enum
-                      else SampleNamespace.Option.values):
+        for value_name in SampleNamespace.Option.__members__:
             enum_item1 = getattr(SampleNamespace.Option, value_name)
             enum_item2 = getattr(SampleNamespace, value_name)
             self.assertEqual(enum_item1, enum_item2)
@@ -70,7 +59,7 @@ class EnumTest(unittest.TestCase):
 
     def testEnumConstructorWithTooManyParameters(self):
         '''Calling the constructor of non-extensible enum with the wrong number of parameters.'''
-        self.assertRaises(TypeError, SampleNamespace.InValue, 13, 14)
+        self.assertRaises((TypeError, ValueError), SampleNamespace.InValue, 13, 14)
 
     def testEnumConstructorWithNonNumberParameter(self):
         '''Calling the constructor of non-extensible enum with a string.'''
@@ -78,8 +67,10 @@ class EnumTest(unittest.TestCase):
 
     def testEnumItemAsDefaultValueToIntArgument(self):
         '''Calls function with an enum item as default value to an int argument.'''
-        self.assertEqual(SampleNamespace.enumItemAsDefaultValueToIntArgument(), SampleNamespace.ZeroIn)
-        self.assertEqual(SampleNamespace.enumItemAsDefaultValueToIntArgument(SampleNamespace.ZeroOut), SampleNamespace.ZeroOut)
+        self.assertEqual(SampleNamespace.enumItemAsDefaultValueToIntArgument(),
+                         SampleNamespace.ZeroIn)
+        self.assertEqual(SampleNamespace.enumItemAsDefaultValueToIntArgument(SampleNamespace.ZeroOut),  # noqa E:501
+                         SampleNamespace.ZeroOut)
         self.assertEqual(SampleNamespace.enumItemAsDefaultValueToIntArgument(123), 123)
 
     def testAnonymousGlobalEnums(self):
@@ -107,54 +98,22 @@ class EnumTest(unittest.TestCase):
         event.setEventTypeByConstPtr(Event.BASIC_EVENT)
         self.assertEqual(event.eventType(), Event.BASIC_EVENT)
 
-    @unittest.skipIf(sys.pyside63_option_python_enum, "test not suitable for Python enum")
-    def testEnumTpPrintImplementation(self):
-        '''Without SbkEnum.tp_print 'print' returns the enum represented as an int.'''
-        tmpfile = createTempFile()
-        print(Event.ANY_EVENT, file=tmpfile)
-        tmpfile.seek(0)
-        text = tmpfile.read().strip()
-        tmpfile.close()
-        self.assertEqual(text, str(Event.ANY_EVENT))
-        self.assertEqual(text, repr(Event.ANY_EVENT))
-
     def testEnumArgumentWithDefaultValue(self):
         '''Option enumArgumentWithDefaultValue(Option opt = UnixTime);'''
         self.assertEqual(SampleNamespace.enumArgumentWithDefaultValue(), SampleNamespace.UnixTime)
-        self.assertEqual(SampleNamespace.enumArgumentWithDefaultValue(SampleNamespace.RandomNumber), SampleNamespace.RandomNumber)
-
-    @unittest.skipIf(sys.pyside63_option_python_enum, "test not suitable for Python enum")
-    def testSignature(self):
-        enum = SampleNamespace.Option(1)
-        types = type(enum).mro()
-        klass = types[0]
-        base = types[1]
-        # The class has an empty signature.
-
-        self.assertEqual(get_signature(klass), None)
-        # The base class must be Enum
-        self.assertNotEqual(get_signature(base), None)
-        # It contains an int annotation.
-        param = get_signature(base).parameters["itemValue"]
-        self.assertEqual(param.annotation, int)
+        self.assertEqual(SampleNamespace.enumArgumentWithDefaultValue(SampleNamespace.RandomNumber),  # noqa E:501
+                         SampleNamespace.RandomNumber)
 
 
 class MyEvent(Event):
     def __init__(self):
-        Event.__init__(self, Event.EventType(3 if sys.pyside63_option_python_enum else 999))
+        Event.__init__(self, Event.EventType(3))
 
 
 class OutOfBoundsTest(unittest.TestCase):
     def testValue(self):
         e = MyEvent()
-        self.assertEqual(repr(e.eventType()), "<EventType.ANY_EVENT: 3>"
-            if sys.pyside63_option_python_enum else 'sample.Event.EventType(999)')
-
-    @unittest.skipIf(sys.pyside63_option_python_enum, "test not suitable for Python enum")
-    def testNoneName(self):
-        e = MyEvent()
-        t = e.eventType()
-        self.assertEqual(t.name, None)
+        self.assertEqual(repr(e.eventType()), "<EventType.ANY_EVENT: 3>")
 
 
 class EnumOverloadTest(unittest.TestCase):
@@ -177,4 +136,3 @@ class EnumOperators(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/enumfromremovednamespace_test.py b/sources/shiboken6/tests/samplebinding/enumfromremovednamespace_test.py
index 1551703a7..42ae23961 100644
--- a/sources/shiboken6/tests/samplebinding/enumfromremovednamespace_test.py
+++ b/sources/shiboken6/tests/samplebinding/enumfromremovednamespace_test.py
@@ -14,22 +14,11 @@ init_paths()
 import sample
 from shiboken_test_helper import objectFullname
 
-from shiboken6 import Shiboken
-
 from shibokensupport.signature import get_signature
 
 
 class TestEnumFromRemovedNamespace(unittest.TestCase):
 
-    @unittest.skipIf(sys.pyside63_option_python_enum, "Makes no sense with strict Enums")
-    def testEnumPromotedToGlobal(self):
-        sample.RemovedNamespace1_Enum
-        self.assertEqual(sample.RemovedNamespace1_Enum_Value0, 0)
-        self.assertEqual(sample.RemovedNamespace1_Enum_Value1, 1)
-        sample.RemovedNamespace1_AnonymousEnum_Value0
-        sample.RemovedNamespace2_Enum
-        sample.RemovedNamespace2_Enum_Value0
-
     def testNames(self):
         # Test if invisible namespace does not appear on type name
         self.assertEqual(objectFullname(sample.RemovedNamespace1_Enum),
@@ -55,9 +44,8 @@ class TestEnumFromRemovedNamespace(unittest.TestCase):
         sample.UnremovedNamespace.RemovedNamespace3_AnonymousEnum_Value0
 
     def testNestedFunctionFromRemovedNamespace(self):
-            self.assertEqual(sample.UnremovedNamespace.nestedMathSum(1, 2), 3)
+        self.assertEqual(sample.UnremovedNamespace.nestedMathSum(1, 2), 3)
 
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/event_loop_call_virtual_test.py b/sources/shiboken6/tests/samplebinding/event_loop_call_virtual_test.py
index e61656400..8e13d5d46 100644
--- a/sources/shiboken6/tests/samplebinding/event_loop_call_virtual_test.py
+++ b/sources/shiboken6/tests/samplebinding/event_loop_call_virtual_test.py
@@ -6,14 +6,12 @@
 
 import os
 import sys
-import time
 import unittest
 
 from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
-from random import random
 
 from sample import ObjectType, Event
 
@@ -41,7 +39,7 @@ class TestEventLoop(unittest.TestCase):
         objs = [ObjectType(), NoOverride(), Override()]
 
         evaluated = ObjectType.processEvent(objs,
-                                        Event(Event.BASIC_EVENT))
+                                            Event(Event.BASIC_EVENT))
 
         self.assertEqual(evaluated, 3)
         self.assertTrue(objs[2].called)
diff --git a/sources/shiboken6/tests/samplebinding/event_loop_thread_test.py b/sources/shiboken6/tests/samplebinding/event_loop_thread_test.py
index 2cd1c8d0a..8b854fca6 100644
--- a/sources/shiboken6/tests/samplebinding/event_loop_thread_test.py
+++ b/sources/shiboken6/tests/samplebinding/event_loop_thread_test.py
@@ -64,7 +64,7 @@ class TestEventLoopWithThread(unittest.TestCase):
         thread.start()
 
         evaluated = ObjectType.processEvent(objs,
-                                        Event(Event.BASIC_EVENT))
+                                            Event(Event.BASIC_EVENT))
 
         thread.join()
 
diff --git a/sources/shiboken6/tests/samplebinding/exception_test.py b/sources/shiboken6/tests/samplebinding/exception_test.py
index 78e583da0..d9e6b377f 100644
--- a/sources/shiboken6/tests/samplebinding/exception_test.py
+++ b/sources/shiboken6/tests/samplebinding/exception_test.py
@@ -13,6 +13,7 @@ init_paths()
 
 from sample import ExceptionTest
 
+
 class CppExceptionTest(unittest.TestCase):
 
     def testVoid(self):
@@ -23,14 +24,14 @@ class CppExceptionTest(unittest.TestCase):
 
         try:
             et.voidThrowStdException(True)
-        except:
+        except:  # noqa: E722
             exceptionCount += 1
 
         et.voidThrowInt(False)
 
         try:
             et.voidThrowInt(True)
-        except:
+        except:  # noqa: E722
             exceptionCount += 1
 
         self.assertEqual(exceptionCount, 2)
@@ -39,18 +40,18 @@ class CppExceptionTest(unittest.TestCase):
         exceptionCount = 0
         et = ExceptionTest()
 
-        result = et.intThrowStdException(False);
+        result = et.intThrowStdException(False)
 
         try:
-            result = et.intThrowStdException(True);
-        except:
+            result = et.intThrowStdException(True)
+        except:  # noqa: E722
             exceptionCount += 1
 
-        result = et.intThrowInt(False);
+        result = et.intThrowInt(False)
 
         try:
-            result = et.intThrowInt(True);
-        except:
+            result = et.intThrowInt(True)  # noqa: F841
+        except:  # noqa: E722
             exceptionCount += 1
 
         self.assertEqual(exceptionCount, 2)
@@ -60,8 +61,8 @@ class CppExceptionTest(unittest.TestCase):
                when return ownership modifications are generated."""
             exceptionCount = 0
             try:
-                et = ExceptionTest.create(True);
-            except:
+                et = ExceptionTest.create(True)  # noqa: F841
+            except:  # noqa: E722
                 exceptionCount += 1
             self.assertEqual(exceptionCount, 1)
 
diff --git a/sources/shiboken6/tests/samplebinding/filter_test.py b/sources/shiboken6/tests/samplebinding/filter_test.py
index 86c5fba2a..df805093f 100644
--- a/sources/shiboken6/tests/samplebinding/filter_test.py
+++ b/sources/shiboken6/tests/samplebinding/filter_test.py
@@ -12,6 +12,7 @@ init_paths()
 
 from sample import Data, Intersection, Union
 
+
 class TestFilters(unittest.TestCase):
 
     def testAnd(self):
@@ -23,5 +24,6 @@ class TestFilters(unittest.TestCase):
 
         self.assertEqual(type(inter), Intersection)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/global.h b/sources/shiboken6/tests/samplebinding/global.h
index f73fdd503..64806417a 100644
--- a/sources/shiboken6/tests/samplebinding/global.h
+++ b/sources/shiboken6/tests/samplebinding/global.h
@@ -56,6 +56,7 @@
 #include "removednamespaces.h"
 #include "sample.h"
 #include "samplenamespace.h"
+#include "stdcomplex.h"
 #include "simplefile.h"
 #include "size.h"
 #include "snakecasetest.h"
diff --git a/sources/shiboken6/tests/samplebinding/handleholder_test.py b/sources/shiboken6/tests/samplebinding/handleholder_test.py
index 273915719..af22328c5 100644
--- a/sources/shiboken6/tests/samplebinding/handleholder_test.py
+++ b/sources/shiboken6/tests/samplebinding/handleholder_test.py
@@ -17,6 +17,7 @@ init_paths()
 
 from sample import HandleHolder
 
+
 class HandleHolderTest(unittest.TestCase):
     def testCreation(self):
         holder = HandleHolder(HandleHolder.createHandle())
@@ -33,5 +34,6 @@ class HandleHolderTest(unittest.TestCase):
         holder2 = HandleHolder(holder.handle2())
         self.assertTrue(holder.compare2(holder2))
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/hashabletype_test.py b/sources/shiboken6/tests/samplebinding/hashabletype_test.py
index 20d3d2edd..c41f5cc06 100644
--- a/sources/shiboken6/tests/samplebinding/hashabletype_test.py
+++ b/sources/shiboken6/tests/samplebinding/hashabletype_test.py
@@ -13,7 +13,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import ObjectType, Str
+
 
 class HashableTest(unittest.TestCase):
 
@@ -29,6 +30,6 @@ class HashableTest(unittest.TestCase):
         h[o] = 2
         self.assertTrue(h.get(o), 2)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/ignorederefop_test.py b/sources/shiboken6/tests/samplebinding/ignorederefop_test.py
index 89df035a3..feb78d045 100644
--- a/sources/shiboken6/tests/samplebinding/ignorederefop_test.py
+++ b/sources/shiboken6/tests/samplebinding/ignorederefop_test.py
@@ -9,12 +9,14 @@ from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
-from sample import *
+from sample import Reference
+
 
 class TestLackOfDereferenceOperators (unittest.TestCase):
     def testIf(self):
         r = Reference()
         self.assertFalse(hasattr(r, "__mul__"))
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/implicitconv_numerical_test.py b/sources/shiboken6/tests/samplebinding/implicitconv_numerical_test.py
index c5c7bc0d1..081666281 100644
--- a/sources/shiboken6/tests/samplebinding/implicitconv_numerical_test.py
+++ b/sources/shiboken6/tests/samplebinding/implicitconv_numerical_test.py
@@ -27,6 +27,7 @@ if is64bitArchitecture and sys.platform != 'win32':
     cLongMin = -9223372036854775808
     cLongMax = 9223372036854775807
 
+
 class NumericTester(unittest.TestCase):
     '''Helper class for numeric comparison testing'''
 
diff --git a/sources/shiboken6/tests/samplebinding/implicitconv_test.py b/sources/shiboken6/tests/samplebinding/implicitconv_test.py
index 96cad9c69..ebafe0c52 100644
--- a/sources/shiboken6/tests/samplebinding/implicitconv_test.py
+++ b/sources/shiboken6/tests/samplebinding/implicitconv_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import ImplicitConv, ObjectType
 
+
 class ImplicitConvTest(unittest.TestCase):
     '''Test case for implicit conversions'''
 
@@ -43,4 +44,3 @@ class ImplicitConvTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/inheritanceandscope_test.py b/sources/shiboken6/tests/samplebinding/inheritanceandscope_test.py
index 7ae676102..28d62486a 100644
--- a/sources/shiboken6/tests/samplebinding/inheritanceandscope_test.py
+++ b/sources/shiboken6/tests/samplebinding/inheritanceandscope_test.py
@@ -15,14 +15,16 @@ init_paths()
 
 from sample import SampleNamespace
 
+
 class ScopeAndInheritanceTest(unittest.TestCase):
     '''Test cases for finding scope in cases involving inheritance.'''
 
     def testMethodCorrectlyWrapper(self):
         '''A method returning a type declared in the scope of the method's
         class parent must be found and the method correctly exported.'''
-        meth = getattr(SampleNamespace.DerivedFromNamespace, 'methodReturningTypeFromParentScope')
+        meth = getattr(SampleNamespace.DerivedFromNamespace,  # noqa: F841
+                       'methodReturningTypeFromParentScope')
+
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/injectcode_test.py b/sources/shiboken6/tests/samplebinding/injectcode_test.py
index 90225a039..f673a7807 100644
--- a/sources/shiboken6/tests/samplebinding/injectcode_test.py
+++ b/sources/shiboken6/tests/samplebinding/injectcode_test.py
@@ -14,6 +14,7 @@ from shiboken_paths import init_paths
 init_paths()
 from sample import InjectCode
 
+
 class MyInjectCode(InjectCode):
     def __init__(self):
         InjectCode.__init__(self)
@@ -22,10 +23,11 @@ class MyInjectCode(InjectCode):
     def arrayMethod(self, values):
         return self.multiplier * sum(values)
 
+
 class InjectCodeTest(unittest.TestCase):
 
     @unittest.skipIf(hasattr(sys, "pypy_version_info"),
-                             "PyPy type objects cannot be modified (yet) after creation")
+                     "PyPy type objects cannot be modified (yet) after creation")
     def testTypeNativeBeginning_TypeTargetBeginning(self):
         ic = InjectCode()
         self.assertEqual(str(ic), "Hi! I'm the inject code dummy class.")
@@ -71,22 +73,24 @@ class InjectCodeTest(unittest.TestCase):
         self.assertEqual(result, sum(values))
 
     def testCallReimplementedVirtualMethodWithArgumentRemovalAndArgumentTypeModification(self):
-        '''Calls a reimplemented virtual method that had its first argument removed and the second modified.'''
+        '''Calls a reimplemented virtual method that had its first argument removed
+           and the second modified.'''
         ic = MyInjectCode()
         values = (1, 2, 3, 4, 5)
         result = ic.callArrayMethod(values)
         self.assertEqual(result, ic.multiplier * sum(values))
 
     def testUsageOfTypeSystemCheckVariableOnPrimitiveType(self):
-        '''When the sequence item is convertible to an integer -1 is returned, or -2 if its not convertible.'''
+        '''When the sequence item is convertible to an integer -1 is returned,
+           or -2 if its not convertible.'''
         ic = InjectCode()
         values = (1, 2, 3, 4, '5', 6.7)
         result = ic.arrayMethod(values)
 
-        fixedValues = [v for v in values if isinstance(v, int)]\
-                    + [-1 for v in values if isinstance(v, float)]\
-                    + [-2 for v in values if not isinstance(v, int) and not isinstance(v, float)]
-        self.assertEqual(result, sum(fixedValues))
+        ints = [v for v in values if isinstance(v, int)]
+        floats = [-1 for v in values if isinstance(v, float)]
+        other = [-2 for v in values if not isinstance(v, int) and not isinstance(v, float)]
+        self.assertEqual(result, sum(ints + floats + other))
 
 
 class IntArrayTest(unittest.TestCase):
@@ -110,5 +114,6 @@ class IntArrayTest(unittest.TestCase):
         ic = InjectCode()
         self.assertEqual(sum([1, 2]) + len([1, 2]), ic.sumArrayAndLength(args))
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/innerclass_test.py b/sources/shiboken6/tests/samplebinding/innerclass_test.py
index f94c57750..721f33483 100644
--- a/sources/shiboken6/tests/samplebinding/innerclass_test.py
+++ b/sources/shiboken6/tests/samplebinding/innerclass_test.py
@@ -13,10 +13,11 @@ init_paths()
 
 from sample import Derived
 
+
 class TestInnerClass(unittest.TestCase):
     def testInstaciate(self):
-        d = Derived.SomeInnerClass()
+        d = Derived.SomeInnerClass()  # noqa: F841
+
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/intlist_test.py b/sources/shiboken6/tests/samplebinding/intlist_test.py
index 41d2b659a..defa9ca71 100644
--- a/sources/shiboken6/tests/samplebinding/intlist_test.py
+++ b/sources/shiboken6/tests/samplebinding/intlist_test.py
@@ -13,6 +13,7 @@ init_paths()
 
 from sample import IntList
 
+
 class IntListTest(unittest.TestCase):
 
     def testAutoFunctionsToBaseList(self):
@@ -74,5 +75,6 @@ class IntListTest(unittest.TestCase):
         self.assertEqual(il[1], int(432.1))
         self.assertRaises(TypeError, il.__setitem__, 2, '78')
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/intwrapper_test.py b/sources/shiboken6/tests/samplebinding/intwrapper_test.py
index 21cab6b35..d883adf47 100644
--- a/sources/shiboken6/tests/samplebinding/intwrapper_test.py
+++ b/sources/shiboken6/tests/samplebinding/intwrapper_test.py
@@ -16,8 +16,8 @@ from sample import IntWrapper
 class IntWrapperTest(unittest.TestCase):
 
     def testOperators(self):
-        ten1  = IntWrapper(10)
-        ten2  = IntWrapper(10)
+        ten1 = IntWrapper(10)
+        ten2 = IntWrapper(10)
         twenty = IntWrapper(20)
         self.assertTrue(ten1 == ten2)
         self.assertTrue(ten1 != twenty)
diff --git a/sources/shiboken6/tests/samplebinding/invalid_virtual_return_test.py b/sources/shiboken6/tests/samplebinding/invalid_virtual_return_test.py
index e3d060430..bb35b2bb1 100644
--- a/sources/shiboken6/tests/samplebinding/invalid_virtual_return_test.py
+++ b/sources/shiboken6/tests/samplebinding/invalid_virtual_return_test.py
@@ -38,7 +38,7 @@ class ModelWrongReturnTest(unittest.TestCase):
     def testWrongTypeReturn(self):
         model = ListModelWrong()
         view = ObjectView(model)
-        self.assertRaises(RuntimeWarning, view.getRawModelData) # calls model.data()
+        self.assertRaises(RuntimeWarning, view.getRawModelData)  # calls model.data()
 
 
 if __name__ == '__main__':
diff --git a/sources/shiboken6/tests/samplebinding/keep_reference_test.py b/sources/shiboken6/tests/samplebinding/keep_reference_test.py
index 6cf416fc4..10591fec6 100644
--- a/sources/shiboken6/tests/samplebinding/keep_reference_test.py
+++ b/sources/shiboken6/tests/samplebinding/keep_reference_test.py
@@ -2,8 +2,6 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-'''Test case for objects that keep references to other object without owning them (e.g. model/view relationships).'''
-
 import os
 import sys
 import unittest
@@ -15,8 +13,10 @@ init_paths()
 
 from sample import ObjectModel, ObjectView
 
+
 class TestKeepReference(unittest.TestCase):
-    '''Test case for objects that keep references to other object without owning them (e.g. model/view relationships).'''
+    '''Test case for objects that keep references to other object without
+       owning them (e.g. model/view relationships).'''
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReferenceCounting(self):
@@ -48,15 +48,16 @@ class TestKeepReference(unittest.TestCase):
         self.assertEqual(sys.getrefcount(model), refcount1)
 
     def testReferreedObjectSurvivalAfterContextEnd(self):
-        '''Model-like object assigned to a view-like object must survive after get out of context.'''
+        '''Model-like object assigned to a view-like object must survive
+           after get out of context.'''
         def createModelAndSetToView(view):
             model = ObjectModel()
             model.setObjectName('created model')
             view.setModel(model)
         view = ObjectView()
         createModelAndSetToView(view)
-        model = view.model()
+        model = view.model()    # noqa: F841
+
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/list_test.py b/sources/shiboken6/tests/samplebinding/list_test.py
index 6eb975b9f..b668bfd90 100644
--- a/sources/shiboken6/tests/samplebinding/list_test.py
+++ b/sources/shiboken6/tests/samplebinding/list_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import ListUser, Point, PointF
 
+
 class ExtendedListUser(ListUser):
     def __init__(self):
         ListUser.__init__(self)
@@ -24,6 +25,7 @@ class ExtendedListUser(ListUser):
         self.create_list_called = True
         return [2, 3, 5, 7, 13]
 
+
 class ListConversionTest(unittest.TestCase):
     '''Test case for std::list container conversions'''
 
@@ -69,7 +71,8 @@ class ListConversionTest(unittest.TestCase):
         self.assertEqual(result, lst)
 
     def testConversionInBothDirectionsWithSimilarContainer(self):
-        '''Test converting a tuple, instead of the expected list, from Python to C++ and back again.'''
+        '''Test converting a tuple, instead of the expected list,
+           from Python to C++ and back again.'''
         lu = ListUser()
         lst = (3, 5, 7)
         lu.setList(lst)
@@ -96,6 +99,6 @@ class ListConversionTest(unittest.TestCase):
         self.assertEqual(ListUser.ListOfPointF, ListUser.listOfPoints([PointF()]))
         self.assertEqual(ListUser.ListOfPoint, ListUser.listOfPoints([Point()]))
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/lock_test.py b/sources/shiboken6/tests/samplebinding/lock_test.py
index 0657d41b9..acd47634a 100644
--- a/sources/shiboken6/tests/samplebinding/lock_test.py
+++ b/sources/shiboken6/tests/samplebinding/lock_test.py
@@ -63,7 +63,8 @@ class TestLockUnlock(unittest.TestCase):
         self.assertTrue(result)
 
     def testReimplementedVirtualBlocker(self):
-        '''Same as the basic case but blocker method is a C++ virtual reimplemented in Python and called from C++.'''
+        '''Same as the basic case but blocker method is a C++ virtual reimplemented
+           in Python and called from C++.'''
         mybucket = MyBucket()
         unlocker = Unlocker(mybucket)
 
@@ -72,5 +73,6 @@ class TestLockUnlock(unittest.TestCase):
         unlocker.join()
         self.assertTrue(result)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/map_test.py b/sources/shiboken6/tests/samplebinding/map_test.py
index 5ffed5ede..fa99ad2e7 100644
--- a/sources/shiboken6/tests/samplebinding/map_test.py
+++ b/sources/shiboken6/tests/samplebinding/map_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import MapUser
 
+
 class ExtendedMapUser(MapUser):
     def __init__(self):
         MapUser.__init__(self)
@@ -22,10 +23,11 @@ class ExtendedMapUser(MapUser):
 
     def createMap(self):
         self.create_map_called = True
-        return {'two' : (complex(2.2, 2.2), 2),
-                'three' : (complex(3.3, 3.3), 3),
-                'five' : (complex(5.5, 5.5), 5),
-                'seven' : (complex(7.7, 7.7), 7)}
+        return {'two': (complex(2.2, 2.2), 2),
+                'three': (complex(3.3, 3.3), 3),
+                'five': (complex(5.5, 5.5), 5),
+                'seven': (complex(7.7, 7.7), 7)}
+
 
 class MapConversionTest(unittest.TestCase):
     '''Test case for std::map container conversions'''
@@ -44,7 +46,7 @@ class MapConversionTest(unittest.TestCase):
     def testConversionInBothDirections(self):
         '''Test converting a map from Python to C++ and back again.'''
         mu = MapUser()
-        map_ = {'odds' : [2, 4, 6], 'evens' : [3, 5, 7], 'primes' : [3, 4, 6]}
+        map_ = {'odds': [2, 4, 6], 'evens': [3, 5, 7], 'primes': [3, 4, 6]}
         mu.setMap(map_)
         result = mu.getMap()
         self.assertEqual(result, map_)
@@ -52,9 +54,10 @@ class MapConversionTest(unittest.TestCase):
     def testConversionMapIntKeyValueTypeValue(self):
         '''C++ signature: MapUser::passMapIntValueType(const std::map<int, const ByteArray>&)'''
         mu = MapUser()
-        map_ = {0 : 'string'}
+        map_ = {0: 'string'}
         result = mu.passMapIntValueType(map_)
         self.assertEqual(map_, result)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/metaclass_test.py b/sources/shiboken6/tests/samplebinding/metaclass_test.py
index 787bace70..4d7eeda96 100644
--- a/sources/shiboken6/tests/samplebinding/metaclass_test.py
+++ b/sources/shiboken6/tests/samplebinding/metaclass_test.py
@@ -10,32 +10,40 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import Point
+
 
 class MetaA(type):
     pass
 
+
 class A(object):
     __metaclass__ = MetaA
 
+
 MetaB = type(Point)
 B = Point
 
+
 class MetaC(MetaA, MetaB):
     pass
+
+
 class C(A, B):
     __metaclass__ = MetaC
 
+
 class D(C):
     pass
 
+
 class TestMetaClass(unittest.TestCase):
     def testIt(self):
-        w1 = C() # works
+        w1 = C()  # works
         w1.setX(1)
         w1.setY(2)
 
-        w2 = D() # should work!
+        w2 = D()  # should work!
         w2.setX(3)
         w2.setY(4)
 
diff --git a/sources/shiboken6/tests/samplebinding/mixed_mi_test.py b/sources/shiboken6/tests/samplebinding/mixed_mi_test.py
index 776605a4d..fa8481600 100644
--- a/sources/shiboken6/tests/samplebinding/mixed_mi_test.py
+++ b/sources/shiboken6/tests/samplebinding/mixed_mi_test.py
@@ -52,5 +52,3 @@ class MixedInheritanceTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
-
diff --git a/sources/shiboken6/tests/samplebinding/modelindex_test.py b/sources/shiboken6/tests/samplebinding/modelindex_test.py
index 725105a9c..e23503eff 100644
--- a/sources/shiboken6/tests/samplebinding/modelindex_test.py
+++ b/sources/shiboken6/tests/samplebinding/modelindex_test.py
@@ -13,6 +13,7 @@ init_paths()
 
 from sample import ModelIndex, ReferentModelIndex, PersistentModelIndex
 
+
 class TestCastOperator(unittest.TestCase):
 
     def testCastOperatorReturningValue(self):
@@ -30,4 +31,3 @@ class TestCastOperator(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/modelview_test.py b/sources/shiboken6/tests/samplebinding/modelview_test.py
index 0b5c657d9..b5663a04e 100644
--- a/sources/shiboken6/tests/samplebinding/modelview_test.py
+++ b/sources/shiboken6/tests/samplebinding/modelview_test.py
@@ -2,7 +2,8 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-'''Test case for objects that keep references to other object without owning them (e.g. model/view relationships).'''
+'''Test case for objects that keep references to other object without owning them
+   (e.g. model/view relationships).'''
 
 import os
 import sys
@@ -17,9 +18,11 @@ from sample import ObjectModel, ObjectType, ObjectView
 
 object_name = 'test object'
 
+
 class MyObject(ObjectType):
     pass
 
+
 class ListModelKeepsReference(ObjectModel):
     def __init__(self, parent=None):
         ObjectModel.__init__(self, parent)
@@ -29,6 +32,7 @@ class ListModelKeepsReference(ObjectModel):
     def data(self):
         return self.obj
 
+
 class ListModelDoesntKeepsReference(ObjectModel):
     def data(self):
         obj = MyObject()
@@ -55,4 +59,3 @@ class ModelViewTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/modifications_test.py b/sources/shiboken6/tests/samplebinding/modifications_test.py
index d1e70004f..dced14396 100644
--- a/sources/shiboken6/tests/samplebinding/modifications_test.py
+++ b/sources/shiboken6/tests/samplebinding/modifications_test.py
@@ -16,6 +16,7 @@ init_paths()
 
 from sample import Modifications, Point, ByteArray
 
+
 class ExtModifications(Modifications):
     def __init__(self):
         Modifications.__init__(self)
@@ -41,25 +42,15 @@ class ModificationsTest(unittest.TestCase):
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
 
-    @unittest.skipIf(sys.pyside63_option_python_enum, "Makes no sense with strict Enums")
-    def testClassMembersAvailability(self):
-        '''Test if Modified class really have the expected members.'''
-        expected_members = set(['OverloadedModFunc', 'OverloadedNone',
-                                'Overloaded_ibiP', 'Overloaded_ibib',
-                                'Overloaded_ibid', 'Overloaded_ibii',
-                                'calculateArea', 'doublePlus', 'increment',
-                                'multiplyPointCoordsPlusValue', 'name',
-                                'pointToPair', 'overloaded', 'power',
-                                'timesTen'])
-        self.assertTrue(expected_members.issubset(dir(Modifications)))
-
     def testRenamedMethodAvailability(self):
-        '''Test if Modification class really have renamed the 'className' virtual method to 'name'.'''
+        '''Test if Modification class really have renamed the 'className'
+           virtual method to 'name'.'''
         self.assertTrue('className' not in dir(Modifications))
         self.assertTrue('name' in dir(Modifications))
 
     def testReimplementationOfRenamedVirtualMethod(self):
-        '''Test if class inheriting from Modification class have the reimplementation of renamed virtual method called.'''
+        '''Test if class inheriting from Modification class have the reimplementation
+           of renamed virtual method called.'''
         em = ExtModifications()
         self.assertEqual(self.mods.name(), 'Modifications')
         self.assertEqual(em.name(), 'ExtModifications')
@@ -80,12 +71,14 @@ class ModificationsTest(unittest.TestCase):
         self.assertEqual(self.mods.doublePlus(7), 14)
 
     def testDefaultValueRemoval(self):
-        '''Test if default value was removed from first argument of Modifications::increment(int).'''
+        '''Test if default value was removed from first argument of
+           Modifications::increment(int).'''
         self.assertRaises(TypeError, self.mods.increment)
         self.assertEqual(self.mods.increment(7), 8)
 
     def testDefaultValueReplacement(self):
-        '''Test if default values for both arguments of Modifications::power(int, int) were modified.'''
+        '''Test if default values for both arguments of Modifications::power(int, int)
+           were modified.'''
         # original default values: int power(int base = 1, int exponent = 0);
         self.assertNotEqual(self.mods.power(4), 1)
         # modified default values: int power(int base = 2, int exponent = 1);
@@ -94,12 +87,14 @@ class ModificationsTest(unittest.TestCase):
         self.assertEqual(self.mods.power(5, 3), 5**3)
 
     def testSetNewDefaultValue(self):
-        '''Test if default value was correctly set to 10 for first argument of Modifications::timesTen(int).'''
+        '''Test if default value was correctly set to 10 for first argument of
+           Modifications::timesTen(int).'''
         self.assertEqual(self.mods.timesTen(7), 70)
         self.assertEqual(self.mods.timesTen(), 100)
 
     def testArgumentRemovalAndReturnTypeModificationWithTypesystemTemplates1(self):
-        '''Test modifications to method signature and return value using type system templates (case 1).'''
+        '''Test modifications to method signature and return value using type
+           system templates (case 1).'''
         result, ok = self.mods.pointToPair(Point(2, 5))
         self.assertEqual(type(ok), bool)
         self.assertEqual(type(result), tuple)
@@ -110,7 +105,8 @@ class ModificationsTest(unittest.TestCase):
         self.assertEqual(result[1], 5.0)
 
     def testArgumentRemovalAndReturnTypeModificationWithTypesystemTemplates2(self):
-        '''Test modifications to method signature and return value using type system templates (case 2).'''
+        '''Test modifications to method signature and return value using
+           type system templates (case 2).'''
         result, ok = self.mods.multiplyPointCoordsPlusValue(Point(2, 5), 4.1)
         self.assertEqual(type(ok), bool)
         self.assertEqual(type(result), float)
@@ -124,9 +120,11 @@ class ModificationsTest(unittest.TestCase):
         self.assertEqual(self.mods.overloaded(1, True, 2), Modifications.Overloaded_ibii)
         # the others weren't modified
         self.assertEqual(self.mods.overloaded(1, True, 2, False), Modifications.Overloaded_ibib)
-        self.assertEqual(self.mods.overloaded(1, False, 2, Point(3, 4)), Modifications.Overloaded_ibiP)
+        self.assertEqual(self.mods.overloaded(1, False, 2, Point(3, 4)),
+                         Modifications.Overloaded_ibiP)
         self.assertRaises(TypeError, self.mods.overloaded, 1, True, Point(2, 3), Point(4, 5))
-        self.assertEqual(self.mods.over(1, True, Point(2, 3), Point(4, 5)), Modifications.Overloaded_ibPP)
+        self.assertEqual(self.mods.over(1, True, Point(2, 3), Point(4, 5)),
+                         Modifications.Overloaded_ibPP)
 
     def testPointArrayModification(self):
         points = (Point(1, 1), Point(2, 2))
diff --git a/sources/shiboken6/tests/samplebinding/modified_constructor_test.py b/sources/shiboken6/tests/samplebinding/modified_constructor_test.py
index d4b65a88a..9791a3491 100644
--- a/sources/shiboken6/tests/samplebinding/modified_constructor_test.py
+++ b/sources/shiboken6/tests/samplebinding/modified_constructor_test.py
@@ -4,7 +4,6 @@
 
 '''Tests cases for ConstructorWithModifiedArgument class.'''
 
-import sys
 import os
 import sys
 import unittest
@@ -14,7 +13,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import ModifiedConstructor
 
 
 class ConstructorWithModifiedArgumentTest(unittest.TestCase):
@@ -24,6 +23,6 @@ class ConstructorWithModifiedArgumentTest(unittest.TestCase):
         sampleClass = ModifiedConstructor("10")
         self.assertTrue(sampleClass.retrieveValue(), 10)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/modifiedvirtualmethods_test.py b/sources/shiboken6/tests/samplebinding/modifiedvirtualmethods_test.py
index ae090f8e3..dcb487f1a 100644
--- a/sources/shiboken6/tests/samplebinding/modifiedvirtualmethods_test.py
+++ b/sources/shiboken6/tests/samplebinding/modifiedvirtualmethods_test.py
@@ -16,6 +16,7 @@ init_paths()
 
 from sample import VirtualMethods, Str
 
+
 class ExtendedVirtualMethods(VirtualMethods):
     def __init__(self):
         VirtualMethods.__init__(self)
@@ -61,7 +62,7 @@ class ExtendedVirtualMethods(VirtualMethods):
         self.callMe_called += 1
 
     def getMargins(self):
-        return tuple([m*2 for m in VirtualMethods.getMargins(self)])
+        return tuple([m * 2 for m in VirtualMethods.getMargins(self)])
 
 
 class VirtualMethodsTest(unittest.TestCase):
@@ -185,7 +186,8 @@ class VirtualMethodsTest(unittest.TestCase):
         removed_arg_value = 2011
         default_value = 3000
         result = self.evm.callSum4(a0, removed_arg_value, a1)
-        self.assertEqual(result, (a0 - removed_arg_value + a1 + default_value) * self.evm.multiplier)
+        self.assertEqual(result,
+                         (a0 - removed_arg_value + a1 + default_value) * self.evm.multiplier)
         self.assertTrue(self.evm.sum4_called)
 
     def testOverridenMethodResultModification(self):
@@ -217,15 +219,15 @@ class VirtualMethodsTest(unittest.TestCase):
     def testExtendedAllArgumentsRemoved(self):
         values = (10, 20, 30, 40)
         self.evm.setMargins(*values)
-        double = tuple([m*2 for m in values])
+        double = tuple([m * 2 for m in values])
         self.assertEqual(self.evm.getMargins(), double)
 
     def testExtendedAllArgumentsRemovedCallVirtual(self):
         values = (10, 20, 30, 40)
         self.evm.setMargins(*values)
-        double = tuple([m*2 for m in values])
+        double = tuple([m * 2 for m in values])
         self.assertEqual(self.evm.callGetMargins(), double)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/multi_cpp_inheritance_test.py b/sources/shiboken6/tests/samplebinding/multi_cpp_inheritance_test.py
index e655b8051..fc6b26c3f 100644
--- a/sources/shiboken6/tests/samplebinding/multi_cpp_inheritance_test.py
+++ b/sources/shiboken6/tests/samplebinding/multi_cpp_inheritance_test.py
@@ -13,72 +13,85 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import ObjectType, Point, Str
+
 
 class SimpleUseCase(ObjectType, Str):
     def __init__(self, name):
         ObjectType.__init__(self)
         Str.__init__(self, name)
 
+
 class SimpleUseCaseReverse(Str, ObjectType):
     def __init__(self, name):
         ObjectType.__init__(self)
         Str.__init__(self, name)
 
+
 class SimpleUseCase2(SimpleUseCase):
     def __init__(self, name):
         SimpleUseCase.__init__(self, name)
 
+
 class ComplexUseCase(SimpleUseCase2, Point):
     def __init__(self, name):
         SimpleUseCase2.__init__(self, name)
         Point.__init__(self)
 
+
 class ComplexUseCaseReverse(Point, SimpleUseCase2):
     def __init__(self, name):
         SimpleUseCase2.__init__(self, name)
         Point.__init__(self)
 
+
 class MultipleCppDerivedTest(unittest.TestCase):
-    def testInstanciation(self):
+    def testInstantiation(self):
         s = SimpleUseCase("Hi")
         self.assertEqual(s, "Hi")
         s.setObjectName(s)
         self.assertEqual(s.objectName(), "Hi")
 
-    def testInstanciation2(self):
+    def testInstantiation2(self):
         s = SimpleUseCase2("Hi")
         self.assertEqual(s, "Hi")
         s.setObjectName(s)
         self.assertEqual(s.objectName(), "Hi")
 
-    def testComplexInstanciation(self):
+    def testComplexInstantiation(self):
         c = ComplexUseCase("Hi")
         self.assertEqual(c, "Hi")
         c.setObjectName(c)
         self.assertEqual(c.objectName(), "Hi")
-        c.setX(2);
+        c.setX(2)
         self.assertEqual(c.x(), 2)
 
+
 class MultipleCppDerivedReverseTest(unittest.TestCase):
-    def testInstanciation(self):
+    def testInstantiation(self):
         s = SimpleUseCaseReverse("Hi")
         self.assertEqual(s, "Hi")
         s.setObjectName(s)
         self.assertEqual(s.objectName(), "Hi")
 
-    def testInstanciation2(self):
+    def testInstantiation2(self):
         s = SimpleUseCase2("Hi")
         self.assertEqual(s, "Hi")
         s.setObjectName(s)
         self.assertEqual(s.objectName(), "Hi")
 
-    def testComplexInstanciation(self):
-        c = ComplexUseCaseReverse("Hi")
-        c.setObjectName(c)
-        self.assertEqual(c.objectName(), "Hi")
-        c.setX(2);
-        self.assertEqual(c, Point(2, 0))
+    def testComplexInstantiation(self):
+        # PYSIDE-1564: This test can no longer work because of this MRO:
+        # ('ComplexUseCaseReverse', 'Point', 'SimpleUseCase2', 'SimpleUseCase',
+        #  'ObjectType', 'Str', 'Object', 'object')
+        # By multiple inheritance Point would be called first but has no argument.
+        with self.assertRaises(TypeError):
+            c = ComplexUseCaseReverse("Hi")  # noqa: F841
+        # c.setObjectName(c)
+        # self.assertEqual(c.objectName(), "Hi")
+        # c.setX(2);
+        # self.assertEqual(c, Point(2, 0))
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/multiple_derived_test.py b/sources/shiboken6/tests/samplebinding/multiple_derived_test.py
index 46e44601d..7497714a8 100644
--- a/sources/shiboken6/tests/samplebinding/multiple_derived_test.py
+++ b/sources/shiboken6/tests/samplebinding/multiple_derived_test.py
@@ -13,17 +13,20 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import Base1, Base2, Base3, Base4, Base5, Base6
+from sample import Base1, Base2
 from sample import MDerived1, MDerived2, MDerived3, MDerived4, MDerived5, SonOfMDerived1
 
+
 class ExtMDerived1(MDerived1):
     def __init__(self):
         MDerived1.__init__(self)
         self.multiplier = 20
         self.base2Method_called = False
+
     def base2Method(self):
         return Base2.base2Method(self) * self.multiplier
 
+
 class MultipleDerivedTest(unittest.TestCase):
     '''Test cases for multiple inheritance'''
 
@@ -40,19 +43,22 @@ class MultipleDerivedTest(unittest.TestCase):
         self.assertTrue(issubclass(MDerived1, Base2))
 
     def testCallToFunctionWithBase1ArgumentThatCastsBackToMDerived1(self):
-        '''MDerived1 is passed as an Base1 argument to a method that returns it casted back to MDerived1.'''
+        '''MDerived1 is passed as an Base1 argument to a method that returns
+           it casted back to MDerived1.'''
         a = MDerived1()
         b = MDerived1.transformFromBase1(a)
         self.assertEqual(a, b)
 
     def testCallToFunctionWithBase2ArgumentThatCastsBackToMDerived1(self):
-        '''MDerived1 is passed as an Base2 argument to a method that returns it casted back to MDerived1.'''
+        '''MDerived1 is passed as an Base2 argument to a method that returns
+           it casted back to MDerived1.'''
         a = MDerived1()
         b = MDerived1.transformFromBase2(a)
         self.assertEqual(a, b)
 
     def testPythonClassIsInstance(self):
-        '''Python defined class ExtMDerived1 is instance of its parents MDerived1, Base1 and Base2.'''
+        '''Python defined class ExtMDerived1 is instance of its parents
+           MDerived1, Base1 and Base2.'''
         a = ExtMDerived1()
         self.assertTrue(isinstance(a, ExtMDerived1))
         self.assertTrue(isinstance(a, MDerived1))
@@ -60,14 +66,16 @@ class MultipleDerivedTest(unittest.TestCase):
         self.assertTrue(isinstance(a, Base2))
 
     def testPythonClassIsSubclass(self):
-        '''Python defined class ExtMDerived1 is subclass of its parents MDerived1, Base1 and Base2.'''
+        '''Python defined class ExtMDerived1 is subclass of its parents
+           MDerived1, Base1 and Base2.'''
         self.assertTrue(issubclass(ExtMDerived1, MDerived1))
         self.assertTrue(issubclass(ExtMDerived1, Base1))
         self.assertTrue(issubclass(ExtMDerived1, Base2))
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived1ToBases(self):
-        '''MDerived1 is casted by C++ to its parents and the binding must return the MDerived1 wrapper.'''
+        '''MDerived1 is casted by C++ to its parents and the binding must return the
+           MDerived1 wrapper.'''
         a = MDerived1()
         refcnt = sys.getrefcount(a)
         b1 = a.castToBase1()
@@ -80,7 +88,8 @@ class MultipleDerivedTest(unittest.TestCase):
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromExtMDerived1ToMDerived1Bases(self):
-        '''Python defined class ExtMDerived1 is casted by C++ to MDerived1 parents and the binding must return the correct ExtMDerived1 instance.'''
+        '''Python defined class ExtMDerived1 is casted by C++ to MDerived1 parents
+           and the binding must return the correct ExtMDerived1 instance.'''
         a = ExtMDerived1()
         refcnt = sys.getrefcount(a)
         b1 = a.castToBase1()
@@ -95,7 +104,8 @@ class MultipleDerivedTest(unittest.TestCase):
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromSonOfMDerived1ToBases(self):
-        '''SonOfMDerived1 is casted by C++ to its parents and the binding must return the SonOfMDerived1 wrapper.'''
+        '''SonOfMDerived1 is casted by C++ to its parents and the binding must return
+           the SonOfMDerived1 wrapper.'''
         a = SonOfMDerived1()
         refcnt = sys.getrefcount(a)
         md1 = a.castToMDerived1()
@@ -116,7 +126,8 @@ class MultipleDerivedTest(unittest.TestCase):
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived2ToBases(self):
-        '''MDerived2 is casted by C++ to its parents and the binding must return the MDerived2 wrapper.'''
+        '''MDerived2 is casted by C++ to its parents and the binding must
+           return the MDerived2 wrapper.'''
         a = MDerived2()
         refcnt = sys.getrefcount(a)
         b3 = a.castToBase3()
@@ -135,7 +146,8 @@ class MultipleDerivedTest(unittest.TestCase):
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived3ToBases(self):
-        '''MDerived3 is casted by C++ to its parents and the binding must return the MDerived3 wrapper.'''
+        '''MDerived3 is casted by C++ to its parents and the binding must
+           return the MDerived3 wrapper.'''
         a = MDerived3()
         refcnt = sys.getrefcount(a)
         md1 = a.castToMDerived1()
@@ -166,7 +178,8 @@ class MultipleDerivedTest(unittest.TestCase):
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived4ToBases(self):
-        '''MDerived4 is casted by C++ to its parents and the binding must return the MDerived4 wrapper.'''
+        '''MDerived4 is casted by C++ to its parents and the binding must
+           return the MDerived4 wrapper.'''
         a = MDerived4()
         refcnt = sys.getrefcount(a)
         b3 = a.castToBase3()
@@ -179,7 +192,8 @@ class MultipleDerivedTest(unittest.TestCase):
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived5ToBases(self):
-        '''MDerived5 is casted by C++ to its parents and the binding must return the MDerived5 wrapper.'''
+        '''MDerived5 is casted by C++ to its parents and the binding must
+           return the MDerived5 wrapper.'''
         a = MDerived5()
         refcnt = sys.getrefcount(a)
         b3 = a.castToBase3()
@@ -192,7 +206,8 @@ class MultipleDerivedTest(unittest.TestCase):
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived3ToBase3(self):
-        '''MDerived3 is casted by C++ to Base3 grandparent using both the inherited and reimplement castToBase3 methods.'''
+        '''MDerived3 is casted by C++ to Base3 grandparent using both the inherited
+           and reimplement castToBase3 methods.'''
         a = MDerived3()
         refcnt = sys.getrefcount(a)
         b3_reimplemented = a.castToBase3()
@@ -203,6 +218,6 @@ class MultipleDerivedTest(unittest.TestCase):
         self.assertEqual(a, b3_inherited)
         self.assertEqual(sys.getrefcount(a), refcnt + 2)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/namespace_test.py b/sources/shiboken6/tests/samplebinding/namespace_test.py
index 2087ced4b..64a6792ac 100644
--- a/sources/shiboken6/tests/samplebinding/namespace_test.py
+++ b/sources/shiboken6/tests/samplebinding/namespace_test.py
@@ -13,11 +13,9 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import SampleNamespace
 from shiboken_test_helper import objectFullname
 
-from shiboken6 import Shiboken
-
 from shibokensupport.signature import get_signature
 
 # For tests of invisible namespaces, see
@@ -26,17 +24,17 @@ from shibokensupport.signature import get_signature
 
 class TestVariablesUnderNamespace(unittest.TestCase):
     def testIt(self):
-         self.assertEqual(SampleNamespace.variableInNamespace, 42)
+        self.assertEqual(SampleNamespace.variableInNamespace, 42)
 
 
 class TestClassesUnderNamespace(unittest.TestCase):
     def testIt(self):
-        c1 = SampleNamespace.SomeClass()
-        e1 = SampleNamespace.SomeClass.ProtectedEnum()
-        c2 = SampleNamespace.SomeClass.SomeInnerClass()
-        e2 = SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum()
-        c3 = SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough()
-        e3 = SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum(0)
+        c1 = SampleNamespace.SomeClass()  # noqa F841
+        e1 = SampleNamespace.SomeClass.ProtectedEnum()  # noqa F841
+        c2 = SampleNamespace.SomeClass.SomeInnerClass()  # noqa F841
+        e2 = SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum()  # noqa F841
+        c3 = SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough()  # noqa F841
+        e3 = SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum(0)  # noqa F841
 
     def testFunctionAddedOnNamespace(self):
         res = SampleNamespace.ImInsideANamespace(2, 2)
@@ -44,25 +42,21 @@ class TestClassesUnderNamespace(unittest.TestCase):
 
     def testTpNames(self):
         self.assertEqual(str(SampleNamespace.SomeClass),
-            "<class 'sample.SampleNamespace.SomeClass'>")
+                         "<class 'sample.SampleNamespace.SomeClass'>")
         self.assertEqual(str(SampleNamespace.SomeClass.ProtectedEnum),
-            "<enum 'ProtectedEnum'>" if sys.pyside63_option_python_enum else
-            "<class 'sample.SampleNamespace.SomeClass.ProtectedEnum'>")
+                         "<enum 'ProtectedEnum'>")
         self.assertEqual(str(SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum),
-            "<enum 'ProtectedEnum'>" if sys.pyside63_option_python_enum else
-            "<class 'sample.SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum'>")
+                         "<enum 'ProtectedEnum'>")
         self.assertEqual(str(SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough),
-            "<class 'sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough'>")
-        self.assertEqual(str(SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum),
-            "<enum 'NiceEnum'>" if sys.pyside63_option_python_enum else
-            "<class 'sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum'>")
+                         "<class 'sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough'>")  # noqa: E501
+        self.assertEqual(str(SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum),  # noqa: E501
+                         "<enum 'NiceEnum'>")
 
         # Test if enum inside of class is correct represented
-        self.assertEqual(objectFullname(get_signature(SampleNamespace.enumInEnumOut).parameters['in_'].annotation),
-            "sample.SampleNamespace.InValue")
-        self.assertEqual(objectFullname(get_signature(SampleNamespace.enumAsInt).parameters['value'].annotation),
-            "sample.SampleNamespace.SomeClass.PublicScopedEnum")
-
+        an = objectFullname(get_signature(SampleNamespace.enumInEnumOut).parameters['in_'].annotation)  # noqa: E501
+        self.assertEqual(an, "sample.SampleNamespace.InValue")
+        an = objectFullname(get_signature(SampleNamespace.enumAsInt).parameters['value'].annotation)
+        self.assertEqual(an, "sample.SampleNamespace.SomeClass.PublicScopedEnum")
 
     def testInlineNamespaces(self):
         cls = SampleNamespace.ClassWithinInlineNamespace()
diff --git a/sources/shiboken6/tests/samplebinding/newdivision_test.py b/sources/shiboken6/tests/samplebinding/newdivision_test.py
index 6286dcfc9..0e7dfbee1 100644
--- a/sources/shiboken6/tests/samplebinding/newdivision_test.py
+++ b/sources/shiboken6/tests/samplebinding/newdivision_test.py
@@ -10,16 +10,16 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import Point
 
 
 class TestNewDivision(unittest.TestCase):
 
     def testIt(self):
         p = Point(4, 4)
-        p2 = p/2
+        p2 = p / 2
         self.assertEqual(p2, Point(2, 2))
 
+
 if __name__ == "__main__":
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/nondefaultctor_test.py b/sources/shiboken6/tests/samplebinding/nondefaultctor_test.py
index 3892508ae..bc8d29e50 100644
--- a/sources/shiboken6/tests/samplebinding/nondefaultctor_test.py
+++ b/sources/shiboken6/tests/samplebinding/nondefaultctor_test.py
@@ -15,14 +15,17 @@ init_paths()
 
 from sample import NonDefaultCtor
 
+
 class DerivedNonDefaultCtor (NonDefaultCtor):
     def returnMyselfVirtual(self):
-        return NonDefaultCtor(self.value()+1)
+        return NonDefaultCtor(self.value() + 1)
+
 
 class AnotherDerivedNonDefaultCtor (NonDefaultCtor):
     def __init__(self, some_string):
         pass
 
+
 class NonDefaultCtorTest(unittest.TestCase):
 
     def testNonDefaultCtor(self):
@@ -43,8 +46,8 @@ class NonDefaultCtorTest(unittest.TestCase):
         self.assertEqual(c.callReturnMyselfVirtual().value(), 4)
 
     def testCtorOverload(self):
-        c = AnotherDerivedNonDefaultCtor("testing")
+        c = AnotherDerivedNonDefaultCtor("testing")  # noqa: F841
+
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/nontypetemplate_test.py b/sources/shiboken6/tests/samplebinding/nontypetemplate_test.py
index fa28abc6d..a10547728 100644
--- a/sources/shiboken6/tests/samplebinding/nontypetemplate_test.py
+++ b/sources/shiboken6/tests/samplebinding/nontypetemplate_test.py
@@ -21,6 +21,7 @@ init_paths()
 
 from sample import IntArray2, IntArray3
 
+
 class NonTypeTemplateTest(unittest.TestCase):
 
     def testNonTypeTemplate(self):
@@ -32,7 +33,7 @@ class NonTypeTemplateTest(unittest.TestCase):
     def testArrayInitializer(self):
         if not hasNumPy:
             return
-        array3 = IntArray3(numpy.array([1, 2, 3], dtype = 'int32'))
+        array3 = IntArray3(numpy.array([1, 2, 3], dtype='int32'))
         self.assertEqual(array3.sum(), 6)
 
 
diff --git a/sources/shiboken6/tests/samplebinding/nonzero_test.py b/sources/shiboken6/tests/samplebinding/nonzero_test.py
index d2a30c7ef..7be239fc4 100644
--- a/sources/shiboken6/tests/samplebinding/nonzero_test.py
+++ b/sources/shiboken6/tests/samplebinding/nonzero_test.py
@@ -13,6 +13,7 @@ init_paths()
 
 from sample import Color, Brush
 
+
 class TestNonZeroOperator(unittest.TestCase):
     def testColor(self):
         """Color has a Qt-style isNull()"""
diff --git a/sources/shiboken6/tests/samplebinding/numericaltypedef_test.py b/sources/shiboken6/tests/samplebinding/numericaltypedef_test.py
index 9539469a1..f714a4fc8 100644
--- a/sources/shiboken6/tests/samplebinding/numericaltypedef_test.py
+++ b/sources/shiboken6/tests/samplebinding/numericaltypedef_test.py
@@ -13,6 +13,7 @@ init_paths()
 
 from sample import SizeF
 
+
 class NumericalTypedefTest(unittest.TestCase):
 
     def testNumericalTypedefExact(self):
@@ -32,5 +33,6 @@ class NumericalTypedefTest(unittest.TestCase):
         self.assertEqual(SizeF.passTypedefOfUnsignedShort(321), 321)
         self.assertNotEqual(SizeF.passTypedefOfUnsignedShort(123), 0)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/numpy_test.py b/sources/shiboken6/tests/samplebinding/numpy_test.py
index af1e6d1bf..42094a463 100644
--- a/sources/shiboken6/tests/samplebinding/numpy_test.py
+++ b/sources/shiboken6/tests/samplebinding/numpy_test.py
@@ -8,7 +8,7 @@ try:
     if bool(sysconfig.get_config_var('Py_DEBUG')):
         sys.exit(0)
     import numpy
-except:
+except:  # noqa: E722
     sys.exit(0)
 
 import os
@@ -21,6 +21,7 @@ from shiboken_paths import init_paths
 init_paths()
 from sample import PointF
 
+
 class TestNumpyTypes(unittest.TestCase):
 
     def testNumpyConverted(self):
@@ -35,6 +36,6 @@ class TestNumpyTypes(unittest.TestCase):
         self.assertAlmostEqual(p.x(), x)
         self.assertAlmostEqual(p.y(), y)
 
+
 if __name__ == "__main__":
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/objecttype_test.py b/sources/shiboken6/tests/samplebinding/objecttype_test.py
index 6e90bfb35..ead68ba13 100644
--- a/sources/shiboken6/tests/samplebinding/objecttype_test.py
+++ b/sources/shiboken6/tests/samplebinding/objecttype_test.py
@@ -68,7 +68,7 @@ class ObjectTypeTest(unittest.TestCase):
     def testNextInFocusChainCycle(self):
         parent = ObjectType()
         child = ObjectType(parent)
-        next_focus = child.nextInFocusChain()
+        next_focus = child.nextInFocusChain()  # noqa: F841
 
         Shiboken.invalidate(parent)
 
@@ -105,5 +105,6 @@ class ObjectTypeTest(unittest.TestCase):
         with self.assertRaises(AttributeError):
             o.typo
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/objecttype_with_named_args_test.py b/sources/shiboken6/tests/samplebinding/objecttype_with_named_args_test.py
index 4e552e887..285e2313b 100644
--- a/sources/shiboken6/tests/samplebinding/objecttype_with_named_args_test.py
+++ b/sources/shiboken6/tests/samplebinding/objecttype_with_named_args_test.py
@@ -13,6 +13,7 @@ init_paths()
 
 from sample import ObjectType
 
+
 class NamedArgsTest(unittest.TestCase):
 
     def testOneArgument(self):
@@ -35,18 +36,15 @@ class NamedArgsTest(unittest.TestCase):
         o.setObjectNameWithSize(size=6, name="pyside")
         self.assertEqual(o.objectName(), "pyside")
 
-
     def testUseDefaultValues(self):
         o = ObjectType()
 
         o.setObjectNameWithSize(size=3)
-        self.assertEqual(o.objectName(), "<un") # use name='unknown' default argument
+        self.assertEqual(o.objectName(), "<un")  # use name='unknown' default argument
 
         o.setObjectSplittedName("")
-        self.assertEqual(o.objectName(), "<unknown>") # user prefix='<unk' and suffix='nown>'
-
+        self.assertEqual(o.objectName(), "<unknown>")  # user prefix='<unk' and suffix='nown>'
 
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/objecttypebyvalue_test.py b/sources/shiboken6/tests/samplebinding/objecttypebyvalue_test.py
index 9dd3baf63..8f74af3ab 100644
--- a/sources/shiboken6/tests/samplebinding/objecttypebyvalue_test.py
+++ b/sources/shiboken6/tests/samplebinding/objecttypebyvalue_test.py
@@ -10,7 +10,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import ObjectTypeByValue
 
 
 class ObjectTypeByValueTest (unittest.TestCase):
@@ -22,5 +22,6 @@ class ObjectTypeByValueTest (unittest.TestCase):
         # just to make sure it will segfault
         obj.prop.protectedValueTypeProperty.setY(2.0)
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/objecttypelayout_test.py b/sources/shiboken6/tests/samplebinding/objecttypelayout_test.py
index ea30f103e..677b89281 100644
--- a/sources/shiboken6/tests/samplebinding/objecttypelayout_test.py
+++ b/sources/shiboken6/tests/samplebinding/objecttypelayout_test.py
@@ -14,7 +14,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import ObjectType, ObjectTypeLayout
 
 
 class ObjectTypeLayoutTest(unittest.TestCase):
@@ -22,16 +22,15 @@ class ObjectTypeLayoutTest(unittest.TestCase):
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testOwnershipOverride(self):
-        l = ObjectTypeLayout()
+        lt = ObjectTypeLayout()
 
-        o1 = ObjectType(l)
+        o1 = ObjectType(lt)
         o1.setObjectName('o1')
 
         self.assertEqual(sys.getrefcount(o1), 3)
-        l.takeChild('o1')
+        lt.takeChild('o1')
         self.assertEqual(sys.getrefcount(o1), 2)
 
-
     def testSetNullLayout(self):
         '''ObjectType.setLayout(0).'''
         o2 = ObjectType()
@@ -57,7 +56,7 @@ class ObjectTypeLayoutTest(unittest.TestCase):
         self.assertEqual(c3.parent(), None)
 
         p1.setLayout(layout)
-        del p1 # This must kill c1, c2 and c3
+        del p1  # This must kill c1, c2 and c3
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
 
@@ -81,7 +80,7 @@ class ObjectTypeLayoutTest(unittest.TestCase):
         self.assertEqual(c3.parent(), None)
 
         p1.setLayout(layout)
-        del p1 # This must kill c1, c2 and c3
+        del p1  # This must kill c1, c2 and c3
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
 
@@ -91,7 +90,8 @@ class ObjectTypeLayoutTest(unittest.TestCase):
         self.assertRaises(RuntimeError, layout.objectName)
 
     def testObjectTypeLayoutTransference(self):
-        '''Transfer a layout from one ObjectType to another, so that all the items in the layout get reparented.'''
+        '''Transfer a layout from one ObjectType to another, so that all the items in
+           the layout get reparented.'''
         p1 = ObjectType()
         p2 = ObjectType()
         c1 = ObjectType()
@@ -154,7 +154,8 @@ class ObjectTypeLayoutTest(unittest.TestCase):
         self.assertRaises(RuntimeError, l2.objectName)
 
     def testObjectTypeLayoutInsideAnotherLayoutAndEveryoneCreatedInCpp(self):
-        '''Adds one ObjectTypeLayout to another and sets the parent to an ObjectType. All the objects are created in C++.'''
+        '''Adds one ObjectTypeLayout to another and sets the parent to an ObjectType.
+           All the objects are created in C++.'''
         p1 = ObjectType.create()
 
         l1 = ObjectTypeLayout.create()
@@ -192,7 +193,8 @@ class ObjectTypeLayoutTest(unittest.TestCase):
         self.assertRaises(RuntimeError, l2.objectName)
 
     def testTransferNestedLayoutsBetweenObjects(self):
-        '''Adds one ObjectTypeLayout to another, sets the parent to an ObjectType and then transfer it to another object.'''
+        '''Adds one ObjectTypeLayout to another, sets the parent to an ObjectType
+           and then transfer it to another object.'''
         p1 = ObjectType()
         p2 = ObjectType()
 
@@ -243,8 +245,8 @@ class ObjectTypeLayoutTest(unittest.TestCase):
         self.assertRaises(RuntimeError, l2.objectName)
 
     def testTransferNestedLayoutsBetweenObjectsAndEveryoneCreatedInCpp(self):
-        '''Adds one ObjectTypeLayout to another, sets the parent to an ObjectType and then transfer it to another object.
-        All the objects are created in C++.'''
+        '''Adds one ObjectTypeLayout to another, sets the parent to an ObjectType and then
+           transfer it to another object. All the objects are created in C++.'''
         p1 = ObjectType.create()
         p2 = ObjectType.create()
 
@@ -294,6 +296,6 @@ class ObjectTypeLayoutTest(unittest.TestCase):
         self.assertRaises(RuntimeError, l1.objectName)
         self.assertRaises(RuntimeError, l2.objectName)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/objecttypeoperators_test.py b/sources/shiboken6/tests/samplebinding/objecttypeoperators_test.py
index ae5936635..ceeee6c8d 100644
--- a/sources/shiboken6/tests/samplebinding/objecttypeoperators_test.py
+++ b/sources/shiboken6/tests/samplebinding/objecttypeoperators_test.py
@@ -10,7 +10,8 @@ from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
-from sample import *
+from sample import ObjectTypeOperators
+
 
 class ObjectTypeOperatorsTest(unittest.TestCase):
 
@@ -26,7 +27,7 @@ class ObjectTypeOperatorsTest(unittest.TestCase):
 
     def testPointerOpeators(self):
         a = ObjectTypeOperators("a")
-        b = ObjectTypeOperators("b")
+        b = ObjectTypeOperators("b")  # noqa: F841
         self.assertEqual(a + "bc", "abc")
         self.assertEqual("bc" + a, "bca")
         self.assertEqual("a", a)
@@ -36,5 +37,6 @@ class ObjectTypeOperatorsTest(unittest.TestCase):
         a = ObjectTypeOperators("a")
         self.assertNotEqual(a, "b")
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/objecttypereferenceasvirtualmethodargument_test.py b/sources/shiboken6/tests/samplebinding/objecttypereferenceasvirtualmethodargument_test.py
index 68e5edecc..5fa6f824e 100644
--- a/sources/shiboken6/tests/samplebinding/objecttypereferenceasvirtualmethodargument_test.py
+++ b/sources/shiboken6/tests/samplebinding/objecttypereferenceasvirtualmethodargument_test.py
@@ -12,6 +12,7 @@ from shiboken_paths import init_paths
 init_paths()
 from sample import ObjectTypeHolder
 
+
 class TestObjectTypeReferenceAsVirtualMethodArgument(unittest.TestCase):
 
     def testBasic(self):
@@ -25,5 +26,6 @@ class TestObjectTypeReferenceAsVirtualMethodArgument(unittest.TestCase):
         holder = Holder('TheObjectFromC++')
         self.assertEqual(holder.callPassObjectTypeAsReference(), 'ThisIsTheObjectFromC++')
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/oddbool_test.py b/sources/shiboken6/tests/samplebinding/oddbool_test.py
index 466ddba82..87a8cdb1f 100644
--- a/sources/shiboken6/tests/samplebinding/oddbool_test.py
+++ b/sources/shiboken6/tests/samplebinding/oddbool_test.py
@@ -15,11 +15,13 @@ init_paths()
 
 from sample import OddBoolUser, ComparisonTester, SpaceshipComparisonTester
 
+
 class DerivedOddBoolUser (OddBoolUser):
     def returnMyselfVirtual(self):
         return OddBoolUser()
     pass
 
+
 class OddBoolTest(unittest.TestCase):
 
     def testOddBoolUser(self):
@@ -30,13 +32,13 @@ class OddBoolTest(unittest.TestCase):
         self.assertEqual(obuTrue.oddBool(), True)
         self.assertEqual(obuTrue.callInvertedOddBool(), False)
 
-        self.assertEqual(obuTrue.oddBool() == True, True)
-        self.assertEqual(False == obuFalse.oddBool(), True)
-        self.assertEqual(obuTrue.oddBool() == obuFalse.oddBool(), False)
+        self.assertTrue(obuTrue.oddBool())
+        self.assertFalse(obuFalse.oddBool())
+        self.assertTrue(obuTrue.oddBool() != obuFalse.oddBool())
 
-        self.assertEqual(obuFalse.oddBool() != True, True)
-        self.assertEqual(True != obuFalse.oddBool(), True)
-        self.assertEqual(obuTrue.oddBool() != obuFalse.oddBool(), True)
+        self.assertFalse(obuFalse.oddBool())
+        self.assertFalse(obuFalse.oddBool())
+        self.assertTrue(obuTrue.oddBool() != obuFalse.oddBool())
 
     def testVirtuals(self):
         dobu = DerivedOddBoolUser()
diff --git a/sources/shiboken6/tests/samplebinding/onlycopyclass_test.py b/sources/shiboken6/tests/samplebinding/onlycopyclass_test.py
index 3bdf431ad..bcb154c52 100644
--- a/sources/shiboken6/tests/samplebinding/onlycopyclass_test.py
+++ b/sources/shiboken6/tests/samplebinding/onlycopyclass_test.py
@@ -13,6 +13,7 @@ init_paths()
 
 from sample import OnlyCopy, FriendOfOnlyCopy
 
+
 class ClassWithOnlyCopyCtorTest(unittest.TestCase):
     def testGetOne(self):
         obj = FriendOfOnlyCopy.createOnlyCopy(123)
@@ -34,5 +35,6 @@ class ClassWithOnlyCopyCtorTest(unittest.TestCase):
         obj = FriendOfOnlyCopy.createOnlyCopy(123)
         self.assertEqual(obj.value(), OnlyCopy.getValueFromReference(obj))
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/overflow_test.py b/sources/shiboken6/tests/samplebinding/overflow_test.py
index bb98f313d..84442306a 100644
--- a/sources/shiboken6/tests/samplebinding/overflow_test.py
+++ b/sources/shiboken6/tests/samplebinding/overflow_test.py
@@ -13,7 +13,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import (Point, doubleLongLong, doubleShort, doubleUnsignedInt,
+                    doubleUnsignedLongLong)
 
 
 class OverflowTest(unittest.TestCase):
@@ -25,14 +26,16 @@ class OverflowTest(unittest.TestCase):
             return super().assertRaises(*args, **kwds)
 
     def testUnsignedInt(self):
-        '''C++ function receives an unsigned int argument and raise OverflowError if the value is negative.'''
+        '''C++ function receives an unsigned int argument and raise OverflowError
+           if the value is negative.'''
         val = 100
         self.assertEqual(doubleUnsignedInt(val), 2 * val)
         val *= -1
         self.assertRaises(OverflowError, doubleUnsignedInt, val)
 
     def testLongLong(self):
-        '''C++ function receives an long long argument and raise OverflowError if the value is negative.'''
+        '''C++ function receives an long long argument and raise OverflowError
+           if the value is negative.'''
         val = 100
         self.assertEqual(doubleLongLong(val), 2 * val)
         val = int(100)
@@ -41,7 +44,8 @@ class OverflowTest(unittest.TestCase):
         self.assertRaises(OverflowError, doubleLongLong, val)
 
     def testUnsignedLongLong(self):
-        '''C++ function receives an unsigned long long argument and raise OverflowError if the value is negative.'''
+        '''C++ function receives an unsigned long long argument and raise OverflowError
+           if the value is negative.'''
         val = 100
         self.assertEqual(doubleUnsignedLongLong(val), 2 * val)
         val = int(100)
@@ -59,13 +63,13 @@ class OverflowTest(unittest.TestCase):
     def testShortOverflow(self):
         '''Calls function with short parameter using an overflowing value.'''
         doubleShort(-3)
-        self.assertRaises(OverflowError, doubleShort, 0xFFFF*-1)
+        self.assertRaises(OverflowError, doubleShort, 0xFFFF * -1)
         self.assertRaises(OverflowError, doubleShort, 0xFFFF + 1)
 
     def testOverflowOnCtor(self):
         '''Calls object ctor with int parameter using overflowing values.'''
         self.assertRaises(OverflowError, Point, 42415335332353253, 42415335332353253)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/overload_sorting_test.py b/sources/shiboken6/tests/samplebinding/overload_sorting_test.py
index 03da96581..060d91510 100644
--- a/sources/shiboken6/tests/samplebinding/overload_sorting_test.py
+++ b/sources/shiboken6/tests/samplebinding/overload_sorting_test.py
@@ -13,11 +13,14 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import (CustomOverloadSequence, ImplicitBase, ImplicitConv,
+                    ImplicitTarget, SortedOverload)
+
 
 class Dummy(object):
     pass
 
+
 class SimpleOverloadSorting(unittest.TestCase):
 
     def setUp(self):
@@ -63,6 +66,7 @@ class DeepOverloadSorting(unittest.TestCase):
         '''Deep Overload - (int, ImplicitBase *)'''
         self.assertEqual(self.obj.overloadDeep(1, ImplicitBase()), "ImplicitBase")
 
+
 class EnumOverIntSorting(unittest.TestCase):
     def testEnumOverInt(self):
         ic = ImplicitConv(ImplicitConv.CtorTwo)
diff --git a/sources/shiboken6/tests/samplebinding/overload_test.py b/sources/shiboken6/tests/samplebinding/overload_test.py
index d6bd90877..62fa8d8d2 100644
--- a/sources/shiboken6/tests/samplebinding/overload_test.py
+++ b/sources/shiboken6/tests/samplebinding/overload_test.py
@@ -21,11 +21,10 @@ def raisesWithErrorMessage(func, arguments, errorType, errorMsg):
     try:
         func(*arguments)
         return False
-    except Exception as err:
-        if type(err) != TypeError:
-            return False
-        if not errorMsg in str(err):
-            return False
+    except TypeError as err:
+        return errorMsg in str(err)
+    except Exception:
+        return False
     return True
 
 
@@ -178,12 +177,13 @@ class OverloadTest(unittest.TestCase):
     def testAcceptSequencePyObject(self):
         # Overload.acceptSequence(void*)
         overload = Overload()
+
         class Foo(object):
             pass
+
         foo = Foo()
         self.assertEqual(overload.acceptSequence(foo), Overload.Function5)
 
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/overloadwithdefault_test.py b/sources/shiboken6/tests/samplebinding/overloadwithdefault_test.py
index 199297415..269b97299 100644
--- a/sources/shiboken6/tests/samplebinding/overloadwithdefault_test.py
+++ b/sources/shiboken6/tests/samplebinding/overloadwithdefault_test.py
@@ -39,6 +39,6 @@ class OverloadTest(unittest.TestCase):
         overload = Overload()
         self.assertEqual(overload.strBufferOverloads(bytes('', "UTF-8"), 0), Overload.Function1)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/ownership_argument_invalidation_test.py b/sources/shiboken6/tests/samplebinding/ownership_argument_invalidation_test.py
index 8a3cdf490..8a55d3ab8 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_argument_invalidation_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_argument_invalidation_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import Polygon, Point
 
+
 class WrapperValidityOfArgumentsTest(unittest.TestCase):
     '''Wrapper validity tests for arguments.'''
 
@@ -25,17 +26,19 @@ class WrapperValidityOfArgumentsTest(unittest.TestCase):
         self.assertRaises(RuntimeError, Polygon.doublePolygonScale, poly)
 
     def testInvalidArgumentToConstructor(self):
-        '''Call to constructor using invalidated Python wrapper as argument should raise RuntimeError.'''
+        '''Call to constructor using invalidated Python wrapper as argument
+           should raise RuntimeError.'''
         pt = Point(1, 2)
         Polygon.stealOwnershipFromPython(pt)
         self.assertRaises(RuntimeError, Polygon, pt)
 
     def testInvalidArgumentWithImplicitConversion(self):
-        '''Call to method using invalidated Python wrapper to be implicitly converted should raise RuntimeError.'''
+        '''Call to method using invalidated Python wrapper to be implicitly converted
+           should raise RuntimeError.'''
         pt = Point(1, 2)
         Polygon.stealOwnershipFromPython(pt)
         self.assertRaises(RuntimeError, Polygon.doublePolygonScale, pt)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/ownership_delete_child_in_cpp_test.py b/sources/shiboken6/tests/samplebinding/ownership_delete_child_in_cpp_test.py
index 2c789a72a..25c6fea26 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_delete_child_in_cpp_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_delete_child_in_cpp_test.py
@@ -30,5 +30,6 @@ class DeleteChildInCpp(unittest.TestCase):
         self.assertRaises(RuntimeError, child.objectName)
         self.assertEqual(parent.objectName(), 'parent')
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/ownership_delete_child_in_python_test.py b/sources/shiboken6/tests/samplebinding/ownership_delete_child_in_python_test.py
index b6f5ce235..3ae186815 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_delete_child_in_python_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_delete_child_in_python_test.py
@@ -35,5 +35,6 @@ class DeleteChildInPython(unittest.TestCase):
         new_child = parent.children()[0]
         self.assertEqual(new_child.objectName(), name)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/ownership_delete_parent_test.py b/sources/shiboken6/tests/samplebinding/ownership_delete_parent_test.py
index 044ef9af6..8f654639c 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_delete_parent_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_delete_parent_test.py
@@ -33,7 +33,7 @@ class DeleteParentTest(unittest.TestCase):
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
         self.assertRaises(RuntimeError, child.objectName)
-        self.assertEqual(sys.getrefcount(child), refcount_before-1)
+        self.assertEqual(sys.getrefcount(child), refcount_before - 1)
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testParentDestructorMultipleChildren(self):
diff --git a/sources/shiboken6/tests/samplebinding/ownership_invalidate_after_use_test.py b/sources/shiboken6/tests/samplebinding/ownership_invalidate_after_use_test.py
index e51b5555f..37b7591e4 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_invalidate_after_use_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_invalidate_after_use_test.py
@@ -21,11 +21,13 @@ class ExtObjectType(ObjectType):
         ObjectType.__init__(self)
         self.type_of_last_event = None
         self.last_event = None
+
     def event(self, event):
         self.last_event = event
         self.type_of_last_event = event.eventType()
         return True
 
+
 class MyObjectType (ObjectType):
     def __init__(self):
         super(MyObjectType, self).__init__()
@@ -35,7 +37,7 @@ class MyObjectType (ObjectType):
         self.callInvalidateEvent(ev)
         try:
             ev.eventType()
-        except:
+        except:  # noqa: E722
             self.fail = True
             raise
         return True
@@ -43,21 +45,25 @@ class MyObjectType (ObjectType):
     def invalidateEvent(self, ev):
         pass
 
+
 class ExtObjectTypeDerived(ObjectTypeDerived):
     def __init__(self):
         ObjectTypeDerived.__init__(self)
         self.type_of_last_event = None
         self.last_event = None
+
     def event(self, event):
         self.last_event = event
         self.type_of_last_event = event.eventType()
         return True
 
+
 class OwnershipInvalidateAfterUseTest(unittest.TestCase):
     '''Ownership tests for cases of invalidation of Python wrapper after use.'''
 
     def testInvalidateAfterUse(self):
-        '''In ObjectType.event(Event*) the wrapper object created for Event must me marked as invalid after the method is called.'''
+        '''In ObjectType.event(Event*) the wrapper object created for Event
+           must me marked as invalid after the method is called.'''
         eot = ExtObjectType()
         eot.causeEvent(Event.SOME_EVENT)
         self.assertEqual(eot.type_of_last_event, Event.SOME_EVENT)
@@ -84,6 +90,6 @@ class OwnershipInvalidateAfterUseTest(unittest.TestCase):
         self.assertEqual(eot.type_of_last_event, Event.SOME_EVENT)
         self.assertRaises(RuntimeError, eot.last_event.eventType)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/ownership_invalidate_child_test.py b/sources/shiboken6/tests/samplebinding/ownership_invalidate_child_test.py
index 868c85931..77b7c576c 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_invalidate_child_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_invalidate_child_test.py
@@ -49,6 +49,6 @@ class InvalidateChildTest(unittest.TestCase):
         self.assertEqual(child1.objectName(), 'child1')
         self.assertRaises(RuntimeError, child2.objectName)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/ownership_invalidate_nonpolymorphic_test.py b/sources/shiboken6/tests/samplebinding/ownership_invalidate_nonpolymorphic_test.py
index 66d6ed5d2..8cbefc30c 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_invalidate_nonpolymorphic_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_invalidate_nonpolymorphic_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import Point, BlackBox
 
+
 class OwnershipInvalidateNonPolymorphicTest(unittest.TestCase):
     '''The BlackBox class has cases of ownership transference between Python and C++.'''
 
@@ -27,6 +28,6 @@ class OwnershipInvalidateNonPolymorphicTest(unittest.TestCase):
         p1_ret = bb.retrievePoint(p1_ticket)
         self.assertEqual(p1_ret, Point(10, 20))
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/ownership_invalidate_parent_test.py b/sources/shiboken6/tests/samplebinding/ownership_invalidate_parent_test.py
index 82ecafa7d..c721a212c 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_invalidate_parent_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_invalidate_parent_test.py
@@ -34,7 +34,7 @@ class InvalidateParentTest(unittest.TestCase):
         grandchild2.setParent(child2)
         bbox = BlackBox()
 
-        bbox.keepObjectType(parent) # Should invalidate the parent
+        bbox.keepObjectType(parent)  # Should invalidate the parent
 
         self.assertRaises(RuntimeError, parent.objectName)
         # some children still valid they are wrapper classes
@@ -43,6 +43,6 @@ class InvalidateParentTest(unittest.TestCase):
         self.assertEqual(grandchild1.objectName(), "grandchild1")
         self.assertRaises(RuntimeError, grandchild2.objectName)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/ownership_reparenting_test.py b/sources/shiboken6/tests/samplebinding/ownership_reparenting_test.py
index acacbf461..304223063 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_reparenting_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_reparenting_test.py
@@ -16,6 +16,7 @@ import sys
 
 from sample import ObjectType
 
+
 class ExtObjectType(ObjectType):
     def __init__(self):
         ObjectType.__init__(self)
@@ -108,4 +109,3 @@ class ReparentingTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/ownership_transference_test.py b/sources/shiboken6/tests/samplebinding/ownership_transference_test.py
index d1eccb4f6..0e9f08b72 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_transference_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_transference_test.py
@@ -16,6 +16,7 @@ init_paths()
 
 from sample import ObjectType, BlackBox
 
+
 class BlackBoxTest(unittest.TestCase):
     '''The BlackBox class has cases of ownership transference between C++ and Python.'''
 
@@ -29,12 +30,13 @@ class BlackBoxTest(unittest.TestCase):
         o2.setObjectName('object2')
         o2_refcnt = sys.getrefcount(o2)
         bb = BlackBox()
-        o1_ticket = bb.keepObjectType(o1)
+        o1_ticket = bb.keepObjectType(o1)  # noqa: F841
         o2_ticket = bb.keepObjectType(o2)
         self.assertEqual(set(bb.objects()), set([o1, o2]))
         self.assertEqual(str(o1.objectName()), 'object1')
         self.assertEqual(str(o2.objectName()), 'object2')
-        self.assertEqual(sys.getrefcount(o1), o1_refcnt + 1) # PySide give +1 ref to object with c++ ownership
+        # PySide give +1 ref to object with c++ ownership
+        self.assertEqual(sys.getrefcount(o1), o1_refcnt + 1)
         self.assertEqual(sys.getrefcount(o2), o2_refcnt + 1)
         o2 = bb.retrieveObjectType(o2_ticket)
         self.assertEqual(sys.getrefcount(o2), o2_refcnt)
@@ -48,9 +50,9 @@ class BlackBoxTest(unittest.TestCase):
     def testBlackBoxReleasingUnknownObjectType(self):
         '''Asks BlackBox to release an unknown ObjectType.'''
         o1 = ObjectType()
-        o2 = ObjectType()
+        o2 = ObjectType()  # noqa: F841
         bb = BlackBox()
-        o1_ticket = bb.keepObjectType(o1)
+        o1_ticket = bb.keepObjectType(o1)  # noqa: F841
         o3 = bb.retrieveObjectType(-5)
         self.assertEqual(o3, None)
 
@@ -59,11 +61,11 @@ class BlackBoxTest(unittest.TestCase):
         '''Ownership transference using a C++ created object.'''
         o1 = ObjectType.create()
         o1.setObjectName('object1')
-        o1_refcnt = sys.getrefcount(o1)
+        o1_refcnt = sys.getrefcount(o1)  # noqa: F841
         bb = BlackBox()
-        o1_ticket = bb.keepObjectType(o1)
+        o1_ticket = bb.keepObjectType(o1)  # noqa: F841
         self.assertRaises(RuntimeError, o1.objectName)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/pair_test.py b/sources/shiboken6/tests/samplebinding/pair_test.py
index 278219434..4bd5c697c 100644
--- a/sources/shiboken6/tests/samplebinding/pair_test.py
+++ b/sources/shiboken6/tests/samplebinding/pair_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import PairUser
 
+
 class ExtendedPairUser(PairUser):
     def __init__(self):
         PairUser.__init__(self)
@@ -24,6 +25,7 @@ class ExtendedPairUser(PairUser):
         self.create_pair_called = True
         return (7, 13)
 
+
 class PairConversionTest(unittest.TestCase):
     '''Test case for std::pair container conversions'''
 
@@ -48,14 +50,16 @@ class PairConversionTest(unittest.TestCase):
         self.assertEqual(cp, (cpx0, cpx1))
 
     def testSumPair(self):
-        '''Test method that sums the items of a pair using values of the types expected by C++ (int and double)'''
+        '''Test method that sums the items of a pair using values of the types
+           expected by C++ (int and double)'''
         pu = PairUser()
         pair = (3, 7.13)
         result = pu.sumPair(pair)
         self.assertEqual(result, sum(pair))
 
     def testSumPairDifferentTypes(self):
-        '''Test method that sums the items of a pair using values of types different from the ones expected by C++ (int and double)'''
+        '''Test method that sums the items of a pair using values of types different
+           from the ones expected by C++ (int and double)'''
         pu = PairUser()
         pair = (3.3, 7)
         result = pu.sumPair(pair)
@@ -71,7 +75,8 @@ class PairConversionTest(unittest.TestCase):
         self.assertEqual(result, pair)
 
     def testConversionInBothDirectionsWithSimilarContainer(self):
-        '''Test converting a list, instead of the expected tuple, from Python to C++ and the other way around.'''
+        '''Test converting a list, instead of the expected tuple, from Python to C++
+           and the other way around.'''
         pu = PairUser()
         pair = [3, 5]
         pu.setPair(pair)
@@ -79,6 +84,6 @@ class PairConversionTest(unittest.TestCase):
         self.assertNotEqual(result, pair)
         self.assertEqual(result, tuple(pair))
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/pen_test.py b/sources/shiboken6/tests/samplebinding/pen_test.py
index 88684dc38..106f3bd61 100644
--- a/sources/shiboken6/tests/samplebinding/pen_test.py
+++ b/sources/shiboken6/tests/samplebinding/pen_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import Color, Pen, SampleNamespace
 
+
 class TestPen(unittest.TestCase):
     '''Simple test case for Pen.'''
 
diff --git a/sources/shiboken6/tests/samplebinding/point_test.py b/sources/shiboken6/tests/samplebinding/point_test.py
index 5e7415395..f86c0f423 100644
--- a/sources/shiboken6/tests/samplebinding/point_test.py
+++ b/sources/shiboken6/tests/samplebinding/point_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import Point
 
+
 class PointTest(unittest.TestCase):
     '''Test case for Point class, including operator overloads.'''
 
@@ -92,5 +93,6 @@ class PointTest(unittest.TestCase):
         expected = Point((pt1.x() + pt2.x()) / 2.0, (pt1.y() + pt2.y()) / 2.0)
         self.assertEqual(pt1.midpoint(pt2), expected)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/pointerholder_test.py b/sources/shiboken6/tests/samplebinding/pointerholder_test.py
index be2faa118..633525a9c 100644
--- a/sources/shiboken6/tests/samplebinding/pointerholder_test.py
+++ b/sources/shiboken6/tests/samplebinding/pointerholder_test.py
@@ -15,8 +15,10 @@ init_paths()
 
 from sample import PointerHolder
 
+
 class TestPointerHolder(unittest.TestCase):
-    '''Test cases for a class that holds an arbitraty pointer and is modified to hold an PyObject.'''
+    '''Test cases for a class that holds an arbitraty pointer and
+       is modified to hold an PyObject.'''
 
     def testStoringAndRetrievingPointer(self):
         ph = PointerHolder('Hello')
@@ -31,9 +33,9 @@ class TestPointerHolder(unittest.TestCase):
         a = (1, 2, 3)
         refcnt = sys.getrefcount(a)
         ph = PointerHolder(a)
-        ptr = ph.pointer()
+        ptr = ph.pointer()  # noqa: F841
         self.assertEqual(sys.getrefcount(a), refcnt + 1)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/pointerprimitivetype_test.py b/sources/shiboken6/tests/samplebinding/pointerprimitivetype_test.py
index 64d51d8c4..4da1a89c6 100644
--- a/sources/shiboken6/tests/samplebinding/pointerprimitivetype_test.py
+++ b/sources/shiboken6/tests/samplebinding/pointerprimitivetype_test.py
@@ -27,7 +27,6 @@ from shiboken_paths import init_paths
 init_paths()
 from sample import IntArray2, VirtualMethods
 
-import shiboken6
 from shibokensupport.signature import get_signature
 
 import typing
@@ -38,7 +37,7 @@ class PointerPrimitiveTypeTest(unittest.TestCase):
     def testArraySignature(self):
         # signature="IntArray2(const int*)"
         found = False
-        for sig in IntArray2.__signature__:
+        for sig in get_signature(IntArray2):
             if "data" in sig.parameters:
                 found = True
                 break
diff --git a/sources/shiboken6/tests/samplebinding/pointf_test.py b/sources/shiboken6/tests/samplebinding/pointf_test.py
index 53616aecb..91c58eb1d 100644
--- a/sources/shiboken6/tests/samplebinding/pointf_test.py
+++ b/sources/shiboken6/tests/samplebinding/pointf_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import PointF
 
+
 class PointFTest(unittest.TestCase):
     '''Test case for PointF class, including operator overloads.'''
 
@@ -45,5 +46,6 @@ class PointFTest(unittest.TestCase):
         expected = PointF((pt1.x() + pt2.x()) / 2.0, (pt1.y() + pt2.y()) / 2.0)
         self.assertEqual(pt1.midpoint(pt2), expected)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/primitivereferenceargument_test.py b/sources/shiboken6/tests/samplebinding/primitivereferenceargument_test.py
index 45cf534a6..0b9fe2249 100644
--- a/sources/shiboken6/tests/samplebinding/primitivereferenceargument_test.py
+++ b/sources/shiboken6/tests/samplebinding/primitivereferenceargument_test.py
@@ -12,12 +12,17 @@ from shiboken_paths import init_paths
 init_paths()
 import sample
 
+
 class PrimitiveReferenceArgumentTest(unittest.TestCase):
 
     def testIntReferenceArgument(self):
         '''C++ signature: int acceptIntReference(int&)'''
         self.assertEqual(sample.acceptIntReference(123), 123)
 
+    def testIntReturnPtr(self):
+        '''C++ signature: const int *acceptIntReturnPtr(int x)'''
+        self.assertEqual(sample.acceptIntReturnPtr(123), 123)
+
     def testOddBoolReferenceArgument(self):
         '''C++ signature: OddBool acceptOddBoolReference(OddBool&)'''
         self.assertEqual(sample.acceptOddBoolReference(True), True)
@@ -25,5 +30,6 @@ class PrimitiveReferenceArgumentTest(unittest.TestCase):
         self.assertNotEqual(sample.acceptOddBoolReference(True), False)
         self.assertNotEqual(sample.acceptOddBoolReference(False), True)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/privatector_test.py b/sources/shiboken6/tests/samplebinding/privatector_test.py
index 235882997..63040388d 100644
--- a/sources/shiboken6/tests/samplebinding/privatector_test.py
+++ b/sources/shiboken6/tests/samplebinding/privatector_test.py
@@ -64,6 +64,6 @@ class PrivateCtorTest(unittest.TestCase):
         self.assertEqual(pd3.instanceCalls(), calls + 2)
         self.assertEqual(sys.getrefcount(pd3), refcnt)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/privatedtor_test.py b/sources/shiboken6/tests/samplebinding/privatedtor_test.py
index 777a9923b..651f63b15 100644
--- a/sources/shiboken6/tests/samplebinding/privatedtor_test.py
+++ b/sources/shiboken6/tests/samplebinding/privatedtor_test.py
@@ -80,6 +80,6 @@ class PrivateDtorTest(unittest.TestCase):
 
         self.assertLess(abs(before - after), 5)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/protected_test.py b/sources/shiboken6/tests/samplebinding/protected_test.py
index 9538125f5..e4ccf721d 100644
--- a/sources/shiboken6/tests/samplebinding/protected_test.py
+++ b/sources/shiboken6/tests/samplebinding/protected_test.py
@@ -16,42 +16,51 @@ init_paths()
 
 from sample import cacheSize
 from sample import ProtectedNonPolymorphic, ProtectedVirtualDestructor
-from sample import ProtectedPolymorphic, ProtectedPolymorphicDaughter, ProtectedPolymorphicGrandDaughter
+from sample import (ProtectedPolymorphic, ProtectedPolymorphicDaughter,
+                    ProtectedPolymorphicGrandDaughter)
 from sample import createProtectedProperty, ProtectedProperty, ProtectedEnumClass
 from sample import PrivateDtor
 from sample import Event, ObjectType, Point
 
+
 class ExtendedProtectedPolymorphic(ProtectedPolymorphic):
     def __init__(self, name):
         ProtectedPolymorphic.__init__(self, name)
         self.protectedName_called = False
+
     def protectedName(self):
         self.protectedName_called = True
         self._name = 'Extended' + ProtectedPolymorphic.protectedName(self)
         return self._name
 
+
 class ExtendedProtectedPolymorphicDaughter(ProtectedPolymorphicDaughter):
     def __init__(self, name):
         self.protectedName_called = False
         ProtectedPolymorphicDaughter.__init__(self, name)
+
     def protectedName(self):
         self.protectedName_called = True
         self._name = 'ExtendedDaughter' + ProtectedPolymorphicDaughter.protectedName(self)
         return self._name
 
+
 class ExtendedProtectedPolymorphicGrandDaughter(ProtectedPolymorphicGrandDaughter):
     def __init__(self, name):
         self.protectedName_called = False
         ProtectedPolymorphicGrandDaughter.__init__(self, name)
+
     def protectedName(self):
         self.protectedName_called = True
         self._name = 'ExtendedGrandDaughter' + ProtectedPolymorphicGrandDaughter.protectedName(self)
         return self._name
 
+
 class ExtendedProtectedVirtualDestructor(ProtectedVirtualDestructor):
     def __init__(self):
         ProtectedVirtualDestructor.__init__(self)
 
+
 class ProtectedNonPolymorphicTest(unittest.TestCase):
     '''Test cases for protected method in a class without virtual methods.'''
 
@@ -81,6 +90,7 @@ class ProtectedNonPolymorphicTest(unittest.TestCase):
         self.assertEqual(p.dataTypeName(1), 'integer')
         self.assertEqual(p.dataTypeName(Point(1, 2)), 'pointer')
 
+
 class ProtectedPolymorphicTest(unittest.TestCase):
     '''Test cases for protected method in a class with virtual methods.'''
 
@@ -110,6 +120,8 @@ class ProtectedPolymorphicTest(unittest.TestCase):
         self.assertTrue(p.protectedName_called)
         self.assertEqual(p.protectedName(), name)
         self.assertEqual(ProtectedPolymorphic.protectedName(p), original_name)
+
+
 class ProtectedPolymorphicDaugherTest(unittest.TestCase):
     '''Test cases for protected method in a class inheriting for a class with virtual methods.'''
 
@@ -153,6 +165,7 @@ class ProtectedPolymorphicGrandDaugherTest(unittest.TestCase):
         self.assertEqual(p.protectedName(), name)
         self.assertEqual(ProtectedPolymorphicGrandDaughter.protectedName(p), original_name)
 
+
 class ProtectedVirtualDtorTest(unittest.TestCase):
     '''Test cases for protected virtual destructor.'''
 
@@ -200,15 +213,18 @@ class ProtectedVirtualDtorTest(unittest.TestCase):
 class ExtendedProtectedEnumClass(ProtectedEnumClass):
     def __init__(self):
         ProtectedEnumClass.__init__(self)
+
     def protectedEnumMethod(self, value):
         if value == ProtectedEnumClass.ProtectedItem0:
             return ProtectedEnumClass.ProtectedItem1
         return ProtectedEnumClass.ProtectedItem0
+
     def publicEnumMethod(self, value):
         if value == ProtectedEnumClass.PublicItem0:
             return ProtectedEnumClass.PublicItem1
         return ProtectedEnumClass.PublicItem0
 
+
 class ProtectedEnumTest(unittest.TestCase):
     '''Test cases for protected enum.'''
 
@@ -223,47 +239,66 @@ class ProtectedEnumTest(unittest.TestCase):
 
         self.assertEqual(type(ProtectedEnumClass.ProtectedItem0), ProtectedEnumClass.ProtectedEnum)
 
-        self.assertEqual(obj.protectedEnumMethod(ProtectedEnumClass.ProtectedItem0), ProtectedEnumClass.ProtectedItem0)
-        self.assertEqual(obj.protectedEnumMethod(ProtectedEnumClass.ProtectedItem1), ProtectedEnumClass.ProtectedItem1)
-
-        self.assertEqual(obj.callProtectedEnumMethod(ProtectedEnumClass.ProtectedItem0), ProtectedEnumClass.ProtectedItem0)
-        self.assertEqual(obj.callProtectedEnumMethod(ProtectedEnumClass.ProtectedItem1), ProtectedEnumClass.ProtectedItem1)
+        self.assertEqual(obj.protectedEnumMethod(ProtectedEnumClass.ProtectedItem0),
+                         ProtectedEnumClass.ProtectedItem0)
+        self.assertEqual(obj.protectedEnumMethod(ProtectedEnumClass.ProtectedItem1),
+                         ProtectedEnumClass.ProtectedItem1)
+        self.assertEqual(obj.callProtectedEnumMethod(ProtectedEnumClass.ProtectedItem0),
+                         ProtectedEnumClass.ProtectedItem0)
+        self.assertEqual(obj.callProtectedEnumMethod(ProtectedEnumClass.ProtectedItem1),
+                         ProtectedEnumClass.ProtectedItem1)
 
     def testProtectedMethodWithPublicEnumArgument(self):
         '''Calls protected method with public enum argument.'''
         obj = ProtectedEnumClass()
 
-        self.assertEqual(obj.publicEnumMethod(ProtectedEnumClass.PublicItem0), ProtectedEnumClass.PublicItem0)
-        self.assertEqual(obj.publicEnumMethod(ProtectedEnumClass.PublicItem1), ProtectedEnumClass.PublicItem1)
+        self.assertEqual(obj.publicEnumMethod(ProtectedEnumClass.PublicItem0),
+                         ProtectedEnumClass.PublicItem0)
+        self.assertEqual(obj.publicEnumMethod(ProtectedEnumClass.PublicItem1),
+                         ProtectedEnumClass.PublicItem1)
 
-        self.assertEqual(obj.callPublicEnumMethod(ProtectedEnumClass.PublicItem0), ProtectedEnumClass.PublicItem0)
-        self.assertEqual(obj.callPublicEnumMethod(ProtectedEnumClass.PublicItem1), ProtectedEnumClass.PublicItem1)
+        self.assertEqual(obj.callPublicEnumMethod(ProtectedEnumClass.PublicItem0),
+                         ProtectedEnumClass.PublicItem0)
+        self.assertEqual(obj.callPublicEnumMethod(ProtectedEnumClass.PublicItem1),
+                         ProtectedEnumClass.PublicItem1)
 
     def testOverriddenProtectedMethodWithProtectedEnumArgument(self):
         '''Calls overridden protected method with protected enum argument.'''
         obj = ExtendedProtectedEnumClass()
 
-        self.assertEqual(obj.protectedEnumMethod(ProtectedEnumClass.ProtectedItem0), ProtectedEnumClass.ProtectedItem1)
-        self.assertEqual(obj.protectedEnumMethod(ProtectedEnumClass.ProtectedItem1), ProtectedEnumClass.ProtectedItem0)
+        self.assertEqual(obj.protectedEnumMethod(ProtectedEnumClass.ProtectedItem0),
+                         ProtectedEnumClass.ProtectedItem1)
+        self.assertEqual(obj.protectedEnumMethod(ProtectedEnumClass.ProtectedItem1),
+                         ProtectedEnumClass.ProtectedItem0)
 
-        self.assertEqual(ProtectedEnumClass.protectedEnumMethod(obj, ProtectedEnumClass.ProtectedItem0), ProtectedEnumClass.ProtectedItem0)
-        self.assertEqual(ProtectedEnumClass.protectedEnumMethod(obj, ProtectedEnumClass.ProtectedItem1), ProtectedEnumClass.ProtectedItem1)
+        self.assertEqual(ProtectedEnumClass.protectedEnumMethod(obj, ProtectedEnumClass.ProtectedItem0),  # noqa: E501
+                         ProtectedEnumClass.ProtectedItem0)
+        self.assertEqual(ProtectedEnumClass.protectedEnumMethod(obj,
+                         ProtectedEnumClass.ProtectedItem1), ProtectedEnumClass.ProtectedItem1)
 
-        self.assertEqual(obj.callProtectedEnumMethod(ProtectedEnumClass.ProtectedItem0), ProtectedEnumClass.ProtectedItem1)
-        self.assertEqual(obj.callProtectedEnumMethod(ProtectedEnumClass.ProtectedItem1), ProtectedEnumClass.ProtectedItem0)
+        self.assertEqual(obj.callProtectedEnumMethod(ProtectedEnumClass.ProtectedItem0),
+                         ProtectedEnumClass.ProtectedItem1)
+        self.assertEqual(obj.callProtectedEnumMethod(ProtectedEnumClass.ProtectedItem1),
+                         ProtectedEnumClass.ProtectedItem0)
 
     def testOverriddenProtectedMethodWithPublicEnumArgument(self):
         '''Calls overridden protected method with public enum argument.'''
         obj = ExtendedProtectedEnumClass()
 
-        self.assertEqual(obj.publicEnumMethod(ProtectedEnumClass.PublicItem0), ProtectedEnumClass.PublicItem1)
-        self.assertEqual(obj.publicEnumMethod(ProtectedEnumClass.PublicItem1), ProtectedEnumClass.PublicItem0)
+        self.assertEqual(obj.publicEnumMethod(ProtectedEnumClass.PublicItem0),
+                         ProtectedEnumClass.PublicItem1)
+        self.assertEqual(obj.publicEnumMethod(ProtectedEnumClass.PublicItem1),
+                         ProtectedEnumClass.PublicItem0)
 
-        self.assertEqual(ProtectedEnumClass.publicEnumMethod(obj, ProtectedEnumClass.PublicItem0), ProtectedEnumClass.PublicItem0)
-        self.assertEqual(ProtectedEnumClass.publicEnumMethod(obj, ProtectedEnumClass.PublicItem1), ProtectedEnumClass.PublicItem1)
+        self.assertEqual(ProtectedEnumClass.publicEnumMethod(obj, ProtectedEnumClass.PublicItem0),
+                         ProtectedEnumClass.PublicItem0)
+        self.assertEqual(ProtectedEnumClass.publicEnumMethod(obj, ProtectedEnumClass.PublicItem1),
+                         ProtectedEnumClass.PublicItem1)
 
-        self.assertEqual(obj.callPublicEnumMethod(ProtectedEnumClass.PublicItem0), ProtectedEnumClass.PublicItem1)
-        self.assertEqual(obj.callPublicEnumMethod(ProtectedEnumClass.PublicItem1), ProtectedEnumClass.PublicItem0)
+        self.assertEqual(obj.callPublicEnumMethod(ProtectedEnumClass.PublicItem0),
+                         ProtectedEnumClass.PublicItem1)
+        self.assertEqual(obj.callPublicEnumMethod(ProtectedEnumClass.PublicItem1),
+                         ProtectedEnumClass.PublicItem0)
 
 
 class ProtectedPropertyTest(unittest.TestCase):
@@ -361,6 +396,6 @@ class PrivateDtorProtectedMethodTest(unittest.TestCase):
         self.assertEqual(obj.instanceCalls(), 2)
         self.assertEqual(obj.instanceCalls(), obj.protectedInstanceCalls())
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/pstrlist_test.py b/sources/shiboken6/tests/samplebinding/pstrlist_test.py
index a257d5944..d60f9cf35 100644
--- a/sources/shiboken6/tests/samplebinding/pstrlist_test.py
+++ b/sources/shiboken6/tests/samplebinding/pstrlist_test.py
@@ -12,6 +12,7 @@ from shiboken_paths import init_paths
 init_paths()
 import sample
 
+
 class PStrListTest(unittest.TestCase):
 
     def testPStrList(self):
@@ -26,5 +27,6 @@ class PStrListTest(unittest.TestCase):
         lst = sample.createListOfPStr(a, b)
         self.assertEqual(lst, [a, b])
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/pystr_test.py b/sources/shiboken6/tests/samplebinding/pystr_test.py
index 3472457e8..ec64c1e31 100644
--- a/sources/shiboken6/tests/samplebinding/pystr_test.py
+++ b/sources/shiboken6/tests/samplebinding/pystr_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import Point
 
+
 class PyStrTest(unittest.TestCase):
     '''Test case for definition of __str__ method.'''
 
@@ -23,6 +24,6 @@ class PyStrTest(unittest.TestCase):
         pt = Point(5, 2)
         self.assertEqual(str(pt), 'Point(5.0, 2.0)')
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/python_thread_test.py b/sources/shiboken6/tests/samplebinding/python_thread_test.py
index 03a75b824..65398b5c6 100644
--- a/sources/shiboken6/tests/samplebinding/python_thread_test.py
+++ b/sources/shiboken6/tests/samplebinding/python_thread_test.py
@@ -36,7 +36,7 @@ class Producer(threading.Thread):
 
     def run(self):
         while self.runs < self.max_runs:
-            value = int(random()*10) % 10
+            value = int(random() * 10) % 10
             self.bucket.push(value)
             self.production_list.append(value)
             logging.debug(f'PRODUCER - pushed {value}')
@@ -66,6 +66,7 @@ class Consumer(threading.Thread):
                 logging.debug('CONSUMER - empty bucket')
             time.sleep(0.01)
 
+
 class ProducerConsumer(unittest.TestCase):
     '''Basic test case for producer-consumer QThread'''
 
@@ -91,8 +92,5 @@ class ProducerConsumer(unittest.TestCase):
         self.assertEqual(prod.production_list, cons.consumption_list)
 
 
-
-
-
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/receive_null_cstring_test.py b/sources/shiboken6/tests/samplebinding/receive_null_cstring_test.py
index f8c7f017d..1d19de941 100644
--- a/sources/shiboken6/tests/samplebinding/receive_null_cstring_test.py
+++ b/sources/shiboken6/tests/samplebinding/receive_null_cstring_test.py
@@ -15,8 +15,10 @@ init_paths()
 
 from sample import countCharacters
 
+
 class ReceiveNullCStringTest(unittest.TestCase):
-    '''Test case for a function that could receive a NULL pointer in a '[const] char*' parameter.'''
+    '''Test case for a function that could receive a NULL pointer in a '[const] char*'
+       parameter.'''
 
     def testBasic(self):
         '''The test function should be working for the basic cases.'''
@@ -29,6 +31,6 @@ class ReceiveNullCStringTest(unittest.TestCase):
         '''The test function returns '-1' when receives a None value instead of a string.'''
         self.assertEqual(countCharacters(None), -1)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/reference_test.py b/sources/shiboken6/tests/samplebinding/reference_test.py
index e590a7e4e..1b6dd3a7a 100644
--- a/sources/shiboken6/tests/samplebinding/reference_test.py
+++ b/sources/shiboken6/tests/samplebinding/reference_test.py
@@ -13,7 +13,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import Reference, Str
+
 
 class ExtendedReference(Reference):
     def __init__(self):
@@ -48,7 +49,7 @@ class ReferenceTest(unittest.TestCase):
     def testCantSegFaultWhenReceiveNone(self):
         '''do not segfault when receiving None as argument.'''
         s = Str()
-        self.assertTrue(None == s)
+        self.assertFalse(bool(s))
 
     def testMethodThatReceivesConstReference(self):
         '''Test a method that receives a const reference to an object as argument.'''
@@ -57,29 +58,33 @@ class ReferenceTest(unittest.TestCase):
         self.assertEqual(Reference.usesConstReference(r), objId)
 
     def testModificationOfReference(self):
-        '''Tests if the identity of a reference argument is preserved when passing it to be altered in C++.'''
+        '''Tests if the identity of a reference argument is preserved when passing
+           it to be altered in C++.'''
         objId = 123
         r1 = Reference(objId)
         r1.alterReferenceIdVirtual(r1)
         self.assertEqual(r1.objId(), objId * Reference.multiplier())
 
     def testModificationOfReferenceCallingAVirtualIndirectly(self):
-        '''Tests if the identity of a reference argument is preserved when passing it to be altered in C++ through a method that calls a virtual method.'''
+        '''Tests if the identity of a reference argument is preserved when passing it
+           to be altered in C++ through a method that calls a virtual method.'''
         objId = 123
         r1 = Reference(objId)
         r1.callAlterReferenceIdVirtual(r1)
         self.assertEqual(r1.objId(), objId * Reference.multiplier())
 
     def testModificationOfReferenceCallingAReimplementedVirtualIndirectly(self):
-        '''Test if a Python override of a virtual method with a reference parameter called from C++ alters the argument properly.'''
+        '''Test if a Python override of a virtual method with a reference parameter
+           called from C++ alters the argument properly.'''
         objId = 123
         r = Reference(objId)
         er = ExtendedReference()
-        result = er.callAlterReferenceIdVirtual(r)
+        result = er.callAlterReferenceIdVirtual(r)  # noqa: F841
         self.assertEqual(r.objId(), objId * er.multiplier)
 
     def testReimplementedVirtualMethodCallWithReferenceParameter(self):
-        '''Test if a Python override of a virtual method with a reference parameter is correctly called from C++.'''
+        '''Test if a Python override of a virtual method with a reference parameter
+           is correctly called from C++.'''
         inc = 9
         objId = 123
         r = Reference(objId)
@@ -88,7 +93,8 @@ class ReferenceTest(unittest.TestCase):
         self.assertEqual(result, objId + inc + er.reference_inc)
 
     def testReimplementedVirtualMethodCallWithConstReferenceParameter(self):
-        '''Test if a Python override of a virtual method with a const reference parameter is correctly called from C++.'''
+        '''Test if a Python override of a virtual method with a const reference
+           parameter is correctly called from C++.'''
         inc = 9
         objId = 123
         r = Reference(objId)
@@ -96,6 +102,6 @@ class ReferenceTest(unittest.TestCase):
         result = er.callUsesConstReferenceVirtual(r, inc)
         self.assertEqual(result, objId + inc + er.const_reference_inc)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/referencetopointer_test.py b/sources/shiboken6/tests/samplebinding/referencetopointer_test.py
index 94bb1608b..942c7ea29 100644
--- a/sources/shiboken6/tests/samplebinding/referencetopointer_test.py
+++ b/sources/shiboken6/tests/samplebinding/referencetopointer_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import VirtualMethods, Str
 
+
 class ExtendedVirtualMethods(VirtualMethods):
     def __init__(self):
         VirtualMethods.__init__(self)
@@ -72,6 +73,6 @@ class ReferenceToPointerTest(unittest.TestCase):
         self.assertTrue(ok)
         self.assertEqual(string, Str(obj.prefix + 'foo'))
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/renaming_test.py b/sources/shiboken6/tests/samplebinding/renaming_test.py
index b6a9a8fa4..b08438ef3 100644
--- a/sources/shiboken6/tests/samplebinding/renaming_test.py
+++ b/sources/shiboken6/tests/samplebinding/renaming_test.py
@@ -16,8 +16,6 @@ init_paths()
 
 from sample import RenamedValue, RenamedUser
 
-from shiboken6 import Shiboken
-
 from shibokensupport.signature import get_signature
 
 
@@ -37,6 +35,5 @@ class RenamingTest(unittest.TestCase):
                                  actual_signature))
 
 
-
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/return_null_test.py b/sources/shiboken6/tests/samplebinding/return_null_test.py
index 46d19e9f7..2c4f07c65 100644
--- a/sources/shiboken6/tests/samplebinding/return_null_test.py
+++ b/sources/shiboken6/tests/samplebinding/return_null_test.py
@@ -13,7 +13,9 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import returnNullPrimitivePointer, returnNullValueTypePointer, returnNullObjectTypePointer
+from sample import (returnNullPrimitivePointer, returnNullValueTypePointer,
+                    returnNullObjectTypePointer)
+
 
 class ReturnNullTest(unittest.TestCase):
     '''Test case for functions that could return a NULL pointer.'''
@@ -33,6 +35,6 @@ class ReturnNullTest(unittest.TestCase):
         o = returnNullValueTypePointer()
         self.assertEqual(o, None)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/richcompare_test.py b/sources/shiboken6/tests/samplebinding/richcompare_test.py
index e764b41a4..3146d0faf 100644
--- a/sources/shiboken6/tests/samplebinding/richcompare_test.py
+++ b/sources/shiboken6/tests/samplebinding/richcompare_test.py
@@ -11,7 +11,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import Expression
+
 
 class TestRichCompare(unittest.TestCase):
 
@@ -22,5 +23,6 @@ class TestRichCompare(unittest.TestCase):
         d = a + c < b + a
         self.assertEqual(d.toString(), "((2+(2+3))<(3+2))")
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/sample_test.py b/sources/shiboken6/tests/samplebinding/sample_test.py
index 52abc968f..19b2f708d 100644
--- a/sources/shiboken6/tests/samplebinding/sample_test.py
+++ b/sources/shiboken6/tests/samplebinding/sample_test.py
@@ -15,35 +15,10 @@ init_paths()
 
 import sample
 
+
 class ModuleTest(unittest.TestCase):
     '''Test case for module and global functions'''
 
-    @unittest.skipIf(sys.pyside63_option_python_enum, "Makes no sense with strict Enums")
-    def testModuleMembers(self):
-        '''Test availability of classes, global functions and other members on binding'''
-        expected_members = set(['Abstract', 'Derived', 'Point',
-                                'ListUser', 'PairUser', 'MapUser',
-                                'gimmeComplexList', 'gimmeDouble', 'gimmeInt',
-                                'makeCString', 'multiplyPair', 'returnCString',
-                                'SampleNamespace', 'transmuteComplexIntoPoint',
-                                'transmutePointIntoComplex', 'sumComplexPair',
-                                'FirstThing', 'SecondThing', 'ThirdThing',
-                                'GlobalEnum', 'NoThing'])
-        self.assertTrue(expected_members.issubset(dir(sample)))
-
-    @unittest.skipIf(sys.pyside63_option_python_enum, "Makes no sense with strict Enums")
-    def testAbstractPrintFormatEnum(self):
-        '''Test availability of PrintFormat enum from Abstract class'''
-        enum_members = set(['PrintFormat', 'Short', 'Verbose',
-                            'OnlyId', 'ClassNameAndId'])
-        self.assertTrue(enum_members.issubset(dir(sample.Abstract)))
-
-    @unittest.skipIf(sys.pyside63_option_python_enum, "Makes no sense with strict Enums")
-    def testSampleNamespaceOptionEnum(self):
-        '''Test availability of Option enum from SampleNamespace namespace'''
-        enum_members = set(['Option', 'None_', 'RandomNumber', 'UnixTime'])
-        self.assertTrue(enum_members.issubset(dir(sample.SampleNamespace)))
-
     def testAddedFunctionAtModuleLevel(self):
         '''Calls function added to module from type system description.'''
         str1 = 'Foo'
@@ -76,7 +51,26 @@ class ModuleTest(unittest.TestCase):
         sample.testNullPtrT(None)
         self.assertRaises(TypeError, sample.testNullPtrT, 42)
 
+    def testRValueRefsWithValueTypes(self):
+        """Passing value types by rvalue refs: For value types, nothing should
+           happen since the argument is copied in the call and the copy is
+           moved from."""
+        polygon = sample.Polygon()
+        polygon.addPoint(sample.Point(1, 2))
+        polygon.addPoint(sample.Point(3, 4))
+        point_count = len(polygon.points())
+        self.assertEqual(point_count, sample.takePolygon(polygon))
+
+    def testRValueRefsWithObjectTypes(self):
+        """Passing object types by rvalue refs: The underlying object should
+           be moved from."""
+        o = sample.ObjectType()
+        object_name = "Name"
+        o.setObjectName(object_name)
+        self.assertEqual(len(object_name), sample.takeObjectType(o))
+        # o should be moved from, name is now empty
+        self.assertEqual(len(o.objectName()), 0)
+
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/samplesnippets.cpp b/sources/shiboken6/tests/samplebinding/samplesnippets.cpp
index 12ff7fc1d..43e6b08de 100644
--- a/sources/shiboken6/tests/samplebinding/samplesnippets.cpp
+++ b/sources/shiboken6/tests/samplebinding/samplesnippets.cpp
@@ -18,3 +18,37 @@ static PyObject *Sbk_IntWrapper_add_ints(PyObject * /* self */, PyObject *args)
 }
 }
 // @snippet intwrapper_add_ints
+
+// @snippet stdcomplex_floor
+%PYARG_0 = PyFloat_FromDouble(std::floor(%CPPSELF.abs_value()));
+// @snippet stdcomplex_floor
+
+// @snippet stdcomplex_ceil
+%PYARG_0 = PyFloat_FromDouble(std::ceil(%CPPSELF.abs_value()));
+// @snippet stdcomplex_ceil
+
+// @snippet stdcomplex_abs
+%PYARG_0 = PyFloat_FromDouble(%CPPSELF.abs_value());
+// @snippet stdcomplex_abs
+
+// @snippet stdcomplex_pow
+%RETURN_TYPE %0 = %CPPSELF.pow(%1);
+%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
+// @snippet stdcomplex_pow
+
+// @snippet size_char_ct
+// Convert a string "{width}x{height}" specification
+{
+    double width = -1;
+    double height = -1;
+    const std::string s = %1;
+    const auto pos = s.find('x');
+    if (pos != std::string::npos) {
+        std::istringstream wstr(s.substr(0, pos));
+        wstr >> width;
+        std::istringstream hstr(s.substr(pos + 1, s.size() - pos - 1));
+        hstr >> height;
+    }
+    %0 = new %TYPE(width, height);
+}
+// @snippet size_char_ct
diff --git a/sources/shiboken6/tests/samplebinding/simplefile_test.py b/sources/shiboken6/tests/samplebinding/simplefile_test.py
index 1217bd9a8..55c894a35 100644
--- a/sources/shiboken6/tests/samplebinding/simplefile_test.py
+++ b/sources/shiboken6/tests/samplebinding/simplefile_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import SimpleFile
 
+
 class SimpleFileTest(unittest.TestCase):
     '''Test cases for SimpleFile class.'''
 
@@ -54,6 +55,6 @@ class SimpleFileTest(unittest.TestCase):
         self.assertRaises(IOError, f.open)
         self.assertEqual(f.size(), 0)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/size_test.py b/sources/shiboken6/tests/samplebinding/size_test.py
index 179a961d9..069ce59b3 100644
--- a/sources/shiboken6/tests/samplebinding/size_test.py
+++ b/sources/shiboken6/tests/samplebinding/size_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import Size
 
+
 class PointTest(unittest.TestCase):
     '''Test case for Size class, including operator overloads.'''
 
@@ -94,6 +95,6 @@ class PointTest(unittest.TestCase):
         self.assertTrue(s1 > s2)
         self.assertFalse(s2 > s1)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/static_nonstatic_methods_test.py b/sources/shiboken6/tests/samplebinding/static_nonstatic_methods_test.py
index e176b3347..cf0889299 100644
--- a/sources/shiboken6/tests/samplebinding/static_nonstatic_methods_test.py
+++ b/sources/shiboken6/tests/samplebinding/static_nonstatic_methods_test.py
@@ -15,16 +15,20 @@ init_paths()
 
 from sample import SimpleFile
 
+
 class SimpleFile2 (SimpleFile):
     def exists(self):
         return "Mooo"
 
+
 class SimpleFile3 (SimpleFile):
     pass
 
+
 class SimpleFile4 (SimpleFile):
     exists = 5
 
+
 class StaticNonStaticMethodsTest(unittest.TestCase):
     '''Test cases for overloads involving static and non-static versions of a method.'''
 
@@ -79,9 +83,9 @@ class StaticNonStaticMethodsTest(unittest.TestCase):
 
     def testDuckPunchingStaticNonStaticMethod(self):
         f = SimpleFile(os.fspath(self.existing_filename))
-        f.exists = lambda : "Meee"
+        f.exists = lambda: "Meee"
         self.assertEqual(f.exists(), "Meee")
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/stdcomplex_test.py b/sources/shiboken6/tests/samplebinding/stdcomplex_test.py
new file mode 100644
index 000000000..0caa9764d
--- /dev/null
+++ b/sources/shiboken6/tests/samplebinding/stdcomplex_test.py
@@ -0,0 +1,71 @@
+#!/usr/bin/env 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 StdComplex class'''
+
+import os
+import math
+import sys
+import unittest
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from shiboken_paths import init_paths
+init_paths()
+
+from sample import StdComplex
+
+
+REAL = 5.0
+IMAG = 2.3
+
+
+class StdComplexTest(unittest.TestCase):
+    '''Test case for StdComplex class, exercising esoteric number
+       protocols (Py_nb_). For standard number protocols, see Point.'''
+
+    def testConversion(self):
+        pt = StdComplex(REAL, IMAG)
+        self.assertEqual(int(pt), int(round(pt.abs_value())))
+        self.assertEqual(float(pt), pt.abs_value())
+
+    def testAbs(self):
+        pt = StdComplex(REAL, IMAG)
+        self.assertEqual(abs(pt), pt.abs_value())
+
+    def testPow(self):
+        '''Compare pow() function to builtin Python type.'''
+        pt = StdComplex(REAL, IMAG)
+        result = pow(pt, StdComplex(2.0, 0))
+        py_pt = complex(REAL, IMAG)
+        py_result = pow(py_pt, complex(2.0, 0))
+        self.assertAlmostEqual(result.real(), py_result.real)
+        self.assertAlmostEqual(result.imag(), py_result.imag)
+
+    def testFloor(self):
+        pt = StdComplex(REAL, IMAG)
+        self.assertEqual(math.floor(pt), math.floor(pt.abs_value()))
+
+    def testCeil(self):
+        pt = StdComplex(REAL, IMAG)
+        self.assertEqual(math.ceil(pt), math.ceil(pt.abs_value()))
+
+    def testPlusOperator(self):
+        '''Test StdComplex class + operator.'''
+        pt1 = StdComplex(REAL, IMAG)
+        pt2 = StdComplex(0.5, 3.2)
+        self.assertEqual(pt1 + pt2, StdComplex(REAL + 0.5, IMAG + 3.2))
+
+    def testEqualOperator(self):
+        '''Test StdComplex class == operator.'''
+        pt1 = StdComplex(REAL, IMAG)
+        pt2 = StdComplex(REAL, IMAG)
+        pt3 = StdComplex(0.5, 3.2)
+        self.assertTrue(pt1 == pt1)
+        self.assertTrue(pt1 == pt2)
+        self.assertFalse(pt1 == pt3)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/str_test.py b/sources/shiboken6/tests/samplebinding/str_test.py
index 97df76452..c06fd6428 100644
--- a/sources/shiboken6/tests/samplebinding/str_test.py
+++ b/sources/shiboken6/tests/samplebinding/str_test.py
@@ -2,7 +2,8 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-'''Test cases for a method that receives a reference to class that is implicitly convertible from a Python native type.'''
+'''Test cases for a method that receives a reference to class that is implicitly
+   convertible from a Python native type.'''
 
 import os
 import sys
@@ -15,6 +16,7 @@ init_paths()
 
 from sample import Str
 
+
 class StrTest(unittest.TestCase):
     '''Test cases for thr Str class.'''
 
@@ -31,39 +33,39 @@ class StrTest(unittest.TestCase):
         self.assertEqual(str(s1), 'This is Sparta!')
 
     def testPassPythonTypeImplictlyConvertibleToAClassUsedAsReference(self):
-        '''Test passing a Python class implicitly convertible to a wrapped class that is expected to be passed as reference.'''
+        '''Test passing a Python class implicitly convertible to a wrapped class
+           that is expected to be passed as reference.'''
         s1 = Str('This is %VAR!').arg('Athens')
         self.assertEqual(str(s1), 'This is Athens!')
 
     def testSequenceOperators(self):
         s1 = Str("abcdef")
-        self.assertEqual(len(s1), 6);
-        self.assertEqual(len(Str()), 0);
+        self.assertEqual(len(s1), 6)
+        self.assertEqual(len(Str()), 0)
 
         # getitem
-        self.assertEqual(s1[0], "a");
-        self.assertEqual(s1[1], "b");
-        self.assertEqual(s1[2], "c");
-        self.assertEqual(s1[3], "d");
-        self.assertEqual(s1[4], "e");
-        self.assertEqual(s1[5], "f");
-        self.assertEqual(s1[-1], "f");
-        self.assertEqual(s1[-2], "e");
+        self.assertEqual(s1[0], "a")
+        self.assertEqual(s1[1], "b")
+        self.assertEqual(s1[2], "c")
+        self.assertEqual(s1[3], "d")
+        self.assertEqual(s1[4], "e")
+        self.assertEqual(s1[5], "f")
+        self.assertEqual(s1[-1], "f")
+        self.assertEqual(s1[-2], "e")
 
         self.assertRaises(TypeError, s1.__getitem__, 6)
 
         # setitem
         s1[0] = 'A'
         s1[1] = 'B'
-        self.assertEqual(s1[0], 'A');
-        self.assertEqual(s1[1], 'B');
+        self.assertEqual(s1[0], 'A')
+        self.assertEqual(s1[1], 'B')
         self.assertRaises(TypeError, s1.__setitem__(6, 67))
 
     def testReverseOperator(self):
         s1 = Str("hello")
-        n1 = 2
-        self.assertEqual(s1+2, "hello2")
-        self.assertEqual(2+s1, "2hello")
+        self.assertEqual(s1 + 2, "hello2")
+        self.assertEqual(2 + s1, "2hello")
 
     def testToIntError(self):
         self.assertEqual(Str('Z').toInt(), (0, False))
@@ -90,6 +92,6 @@ class StrTest(unittest.TestCase):
         self.assertEqual(val, int(str(hexa), 16))
         self.assertEqual(hexa.toInt(), (0, False))
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/strlist_test.py b/sources/shiboken6/tests/samplebinding/strlist_test.py
index f768f9c63..2bfb80b67 100644
--- a/sources/shiboken6/tests/samplebinding/strlist_test.py
+++ b/sources/shiboken6/tests/samplebinding/strlist_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import Str, StrList
 
+
 class StrListTest(unittest.TestCase):
     '''Test cases for StrList class that inherits from std::list<Str>.'''
 
@@ -88,5 +89,6 @@ class StrListTest(unittest.TestCase):
         self.assertEqual(len(sl), 2)
         self.assertEqual(sl, (Str('Foo'), 'Bar'))
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/templateinheritingclass_test.py b/sources/shiboken6/tests/samplebinding/templateinheritingclass_test.py
index f458ad0d2..11279c7ec 100644
--- a/sources/shiboken6/tests/samplebinding/templateinheritingclass_test.py
+++ b/sources/shiboken6/tests/samplebinding/templateinheritingclass_test.py
@@ -14,7 +14,8 @@ init_paths()
 from sample import Photon
 
 '''This tests classes that inherit from template classes,
-simulating a situation found in Qt's phonon module.'''
+   simulating a situation found in Qt's phonon module.'''
+
 
 class TemplateInheritingClassTest(unittest.TestCase):
     def testClassBasics(self):
@@ -57,5 +58,6 @@ class TemplateInheritingClassTest(unittest.TestCase):
         self.assertEqual(obj2, obj2.passPointerThrough(obj2))
         self.assertRaises(TypeError, obj1.passPointerThrough, obj2)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/time_test.py b/sources/shiboken6/tests/samplebinding/time_test.py
index 9b32aaaee..6283a6744 100644
--- a/sources/shiboken6/tests/samplebinding/time_test.py
+++ b/sources/shiboken6/tests/samplebinding/time_test.py
@@ -4,7 +4,6 @@
 
 '''Test cases for constructor and method signature decisor on Time class.'''
 
-import sys
 import os
 import sys
 import unittest
@@ -17,6 +16,7 @@ import datetime
 
 from sample import Time, ImplicitConv, ObjectType
 
+
 class TimeTest(unittest.TestCase):
     '''Test cases for constructor and method signature decisor on Time class.
     The constructor and one method have these signatures: CTORMETHOD() and
@@ -115,6 +115,6 @@ class TimeTest(unittest.TestCase):
         py = datetime.time(12, 32, 5)
         self.assertNotEqual(time, py)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/transform_test.py b/sources/shiboken6/tests/samplebinding/transform_test.py
index a938e6af8..7dfd18a4a 100644
--- a/sources/shiboken6/tests/samplebinding/transform_test.py
+++ b/sources/shiboken6/tests/samplebinding/transform_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import Point, applyHomogeneousTransform
 
+
 class TransformTest(unittest.TestCase):
     '''Test cases for modifying a function with > 9 arguments.'''
 
@@ -32,5 +33,6 @@ class TransformTest(unittest.TestCase):
         r = applyHomogeneousTransform(p, 1, 0, 0, 0, 1, 0, 0, 0, 0)
         self.assertTrue(r is None)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/typeconverters_test.py b/sources/shiboken6/tests/samplebinding/typeconverters_test.py
index 10b7491b1..987ba6dfd 100644
--- a/sources/shiboken6/tests/samplebinding/typeconverters_test.py
+++ b/sources/shiboken6/tests/samplebinding/typeconverters_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 import sample
 
+
 class GetPythonTypeByNameTest(unittest.TestCase):
 
     '''Uses an added function with inject code that uses the libshiboken
@@ -159,12 +160,31 @@ class StringBasedConversionTest(unittest.TestCase):
         self.assertTrue(len(result), 1)
         self.assertTrue(lst, result[0])
 
+
+class PrimitiveConversionTest(unittest.TestCase):
+
     def testCppPrimitiveType(self):
         integers = (12, 34)
         result = sample.convertIntegersToCppAndThenToPython(integers[0], integers[1])
         for orig, new in zip(integers, result):
             self.assertEqual(orig, new)
 
+    def testLargeIntAsFloat(self):
+        """PYSIDE-2417: When passing an int to a function taking float,
+           a 64bit conversion should be done."""
+        point = sample.PointF(1, 2)
+        large_int = 2**31 + 2
+        point.setX(large_int)
+        self.assertEqual(round(point.x()), large_int)
+
+    def testUnsignedLongLongAsFloat(self):
+        """PYSIDE-2652: When passing an unsigned long long to a function taking float,
+           an unsigned 64bit conversion should be done."""
+        point = sample.PointF(1, 2)
+        large_int = 2**63
+        point.setX(large_int)
+        self.assertEqual(round(point.x()), large_int)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/typedealloc_test.py b/sources/shiboken6/tests/samplebinding/typedealloc_test.py
index 1b47c62bc..ce881e802 100644
--- a/sources/shiboken6/tests/samplebinding/typedealloc_test.py
+++ b/sources/shiboken6/tests/samplebinding/typedealloc_test.py
@@ -33,12 +33,16 @@ class TypeDeallocTest(unittest.TestCase):
 
     def testScopeEnd(self):
         ref = None
+
         def scope():
+
             class Ext(Point):
                 pass
-            o = Ext()
+
+            o = Ext()  # noqa: F841
             global ref
             ref = weakref.ref(Ext, self.callback)
+
         scope()
         gc.collect()
         self.assertTrue(self.called)
@@ -46,7 +50,7 @@ class TypeDeallocTest(unittest.TestCase):
     def testDeleteType(self):
         class Ext(Point):
             pass
-        ref = weakref.ref(Ext, self.callback)
+        ref = weakref.ref(Ext, self.callback)  # noqa: F841
         del Ext
         gc.collect()
         self.assertTrue(self.called)
@@ -54,4 +58,3 @@ class TypeDeallocTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/typedtordoublefree_test.py b/sources/shiboken6/tests/samplebinding/typedtordoublefree_test.py
index c486f2bcc..ab8e535b5 100644
--- a/sources/shiboken6/tests/samplebinding/typedtordoublefree_test.py
+++ b/sources/shiboken6/tests/samplebinding/typedtordoublefree_test.py
@@ -12,6 +12,7 @@ from shiboken_paths import init_paths
 init_paths()
 from sample import ObjectType
 
+
 class TestTypeDestructorDoubleFree(unittest.TestCase):
     def testTypeDestructorDoubleFree(self):
         '''Causes the type destructors of two derived classes to be called.'''
@@ -22,13 +23,16 @@ class TestTypeDestructorDoubleFree(unittest.TestCase):
             obj = ExtObj1()
             child = ObjectType(parent=obj)
             self.assertEqual(obj.takeChild(child), child)
+
             class ExtObj2(ObjectType):
                 def __init__(self):
                     ObjectType.__init__(self)
+
             obj = ExtObj2()
             child = ObjectType(parent=obj)
             self.assertEqual(obj.takeChild(child), child)
         scope()
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/typesystem_sample.xml b/sources/shiboken6/tests/samplebinding/typesystem_sample.xml
index d7f45d8b6..e315e599e 100644
--- a/sources/shiboken6/tests/samplebinding/typesystem_sample.xml
+++ b/sources/shiboken6/tests/samplebinding/typesystem_sample.xml
@@ -1,12 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <typesystem package="sample">
-    <suppress-warning text="Duplicate type entry: 'sample'" />
-    <suppress-warning text="Duplicate type entry: 'SampleNamespace'" />
-
     <primitive-type name="ObjectType::Identifier"/>
     <primitive-type name="std::nullptr_t"/>
 
-    <primitive-type name="Foo::HANDLE" target-lang-api-name="PyLong"/>
+    <primitive-type name="Foo::SAMPLE_HANDLE" target-lang-api-name="PyLong"/>
 
     <primitive-type name="std::size_t" target-lang-api-name="PyLong">
         <conversion-rule>
@@ -74,7 +71,7 @@
         </conversion-rule>
     </primitive-type>
 
-    <primitive-type name="HANDLE" target-lang-api-name="PyComplex">
+    <primitive-type name="SAMPLE_HANDLE" target-lang-api-name="PyComplex">
         <include file-name="handle.h" location="local"/>
         <conversion-rule>
             <native-to-target>
@@ -400,6 +397,7 @@
     <function signature="returnNullValueTypePointer()" />
     <function signature="returnNullObjectTypePointer()" />
     <function signature="acceptInt(int)" />
+    <function signature="acceptIntReturnPtr(int)"/>
     <function signature="acceptUInt(unsigned int)" />
     <function signature="acceptLong(long)" />
     <function signature="acceptULong(unsigned long)" />
@@ -421,6 +419,8 @@
     <function signature="addStdStrings(const std::string&amp;, const std::string&amp;)"/>
     <function signature="addStdWStrings(const std::wstring&amp;, const std::wstring&amp;)"/>
     <function signature="testNullPtrT(std::nullptr_t)"/>
+    <function signature="takePolygon(Polygon&amp;&amp;)"/>
+    <function signature="takeObjectType(ObjectType&amp;&amp;)"/>
 
     <value-type name="ArrayModifyTest">
         <modify-function signature="sumIntArray(int, int*)">
@@ -429,7 +429,7 @@
     </value-type>
 
     <value-type name="ClassWithFunctionPointer">
-        <suppress-warning text="skipping function 'ClassWithFunctionPointer::callFunctionPointer', unmatched parameter type 'void (*)(void*)'" />
+        <suppress-warning text="^skipping public function 'void ClassWithFunctionPointer::callFunctionPointer.*$" />
     </value-type>
 
     <value-type name="IntArray" generate="no"/>
@@ -571,6 +571,14 @@
         <modify-function signature="hideFunction(HideType*)" remove="all"/>
         <modify-field name="toBeRenamedField" rename="renamedField"/>
         <modify-field name="readOnlyField" write="false"/>
+        <modify-function signature="virtualWithOutParameter(int&amp;)const">
+            <inject-code class="shell" position="override">
+            x = virtualWithOutParameterPyOverride(gil, pyOverride.object());
+            return;
+            </inject-code>
+        </modify-function>
+        <add-function signature="virtualWithOutParameterPyOverride()"
+                      return-type="int" python-override="true"/>
     </object-type>
 
     <object-type name="Derived" polymorphic-id-expression="%1->type() == Derived::TpDerived">
@@ -633,8 +641,8 @@
             // CHECKTYPE and ISCONVERTIBLE are used here for test purposes, don't change them.
             if (!%CHECKTYPE[ObjectTypeLayout*](layout) &amp;&amp; !%ISCONVERTIBLE[ObjectTypeLayout*](layout))
                 return;
-            // %CHECKTYPE[ObjectTypeLayout*](layout)
-            // %ISCONVERTIBLE[ObjectTypeLayout*](layout)
+            /* %CHECKTYPE[ObjectTypeLayout*](layout) */
+            /* %ISCONVERTIBLE[ObjectTypeLayout*](layout) */
             ObjectTypeLayout* var;
             var = %CONVERTTOCPP[ObjectTypeLayout*](layout);
             // TODO-CONVERTER: erase this
@@ -721,7 +729,7 @@
         </modify-function>
     </object-type>
 
-    <value-type name="ObjectTypeHolder"/>
+    <object-type name="ObjectTypeHolder"/>
     <value-type name="OnlyCopy"/>
     <value-type name="FriendOfOnlyCopy"/>
 
@@ -1894,13 +1902,13 @@
 
     </value-type>
     <value-type name="Size">
+        <extra-includes>
+            <include file-name="string" location="global"/>
+            <include file-name="sstream" location="global"/>
+        </extra-includes>
         <add-function signature="Size(const char*)">
-            <inject-code class="target" position="beginning">
-                %0 = new %TYPE();
-            </inject-code>
-            <inject-code class="target" position="end">
-                Shiboken::AutoDecRef result(PyObject_CallMethod(%PYSELF, const_cast&lt;char*>("setHeight"), const_cast&lt;char*>("i"), 2));
-            </inject-code>
+            <inject-code class="target" position="beginning"
+             file="samplesnippets.cpp" snippet="size_char_ct"/>
         </add-function>
     </value-type>
     <value-type name="SizeF"/>
@@ -2217,14 +2225,14 @@
         </add-function>
     </value-type>
 
-    <value-type name="SimpleFile">
+    <object-type name="SimpleFile">
         <modify-function signature="open()">
             <modify-argument index="return">
                 <remove-argument/>
             </modify-argument>
             <inject-code class="target" position="end" file="simplefile_glue.cpp"/>
         </modify-function>
-    </value-type>
+    </object-type>
 
     <value-type name="VoidHolder" />
 
@@ -2401,6 +2409,31 @@
 
     <object-type name="ObjectTypeByValue" />
 
+    <value-type name="StdComplex">
+        <extra-includes>
+            <include file-name="cmath" location="global"/>
+        </extra-includes>
+        <!-- PYSIDE-2446: number protocols without a Py_nb_ constant. -->
+        <add-function signature="__floor__()" return-type="double">
+            <inject-code class="target" position="end"
+                         file="samplesnippets.cpp" snippet="stdcomplex_floor"/>
+        </add-function>
+        <add-function signature="__ceil__()" return-type="double">
+            <inject-code class="target" position="end"
+                         file="samplesnippets.cpp" snippet="stdcomplex_ceil"/>
+        </add-function>
+        <!-- PYSIDE-2446: number protocols with Py_nb_ constants. -->
+        <add-function signature="__abs__()" return-type="double">
+            <inject-code class="target" position="end"
+                         file="samplesnippets.cpp" snippet="stdcomplex_abs"/>
+        </add-function>
+        <add-function signature="__pow__(StdComplex@exp@)" return-type="StdComplex">
+            <inject-code class="target" position="end"
+                         file="samplesnippets.cpp" snippet="stdcomplex_pow"/>
+        </add-function>
+
+    </value-type>
+
     <object-type name="TemplatePtr">
         <modify-function signature="dummy(std::list&lt;std::pair&lt;BlackBox *, BlackBox *&gt; &gt; &amp;)" rename="dummy_method" />
     </object-type>
@@ -2416,20 +2449,9 @@
 
     <suppress-warning text="horribly broken type '__off64_t'" />
     <suppress-warning text="enum '__codecvt_result' does not have a type entry or is not an enum" />
-    <suppress-warning text="Pure virtual method &quot;Abstract::hideFunction(HideType*)&quot; must be implement but was completely removed on typesystem." />
-    <suppress-warning text="hiding of function 'takeChild' in class 'ObjectType'" />
+    <suppress-warning text="Pure virtual method 'Abstract::hideFunction(HideType*)' must be implemented but was completely removed on type system." />
     <suppress-warning text="Shadowing: MDerived2::castToBase3() and MDerived3::castToBase3()" />
-    <suppress-warning text="hiding of function 'takeChild' in class 'Bucket'" />
-    <suppress-warning text="visibility of function 'publicMethod' modified in class 'MDerived1'" />
-    <suppress-warning text="hiding of function 'doNothingInPublic3' in class 'Overload2'" />
-    <suppress-warning text="hiding of function 'takeChild' in class 'ObjectModel'" />
-    <suppress-warning text="hiding of function 'takeChild' in class 'ObjectView'" />
-    <suppress-warning text="visibility of function 'publicMethod' modified in class 'MDerived3'" />
-    <suppress-warning text="skipping function 'InjectCode::toStr', unmatched parameter type 'T const&amp;'" />
-
-    <suppress-warning text="^skipping function 'std::enable_if.*ComparisonTester::operator[!=]=.*ComparisonTester.*$"/>
-
-    <!-- Do not fix this warning, the generator should be able to handle this situation for Object Types. -->
-    <suppress-warning text="Argument in position 1 of added function 'SampleNamespace::passReferenceToObjectType(ObjectType * arg__1)', has a type that is not a reference, while the argument in the corresponding position in C++ function 'SampleNamespace::passReferenceToObjectType(const ObjectType &amp; obj, int multiplier)' is a reference." />
+    <suppress-warning text="Visibility of function 'publicMethod' modified in class 'MDerived1'" />
 
+    <suppress-warning text="^skipping public function 'std::enable_if.*ComparisonTester::operator[!=]=.*ComparisonTester.*$"/>
 </typesystem>
diff --git a/sources/shiboken6/tests/samplebinding/typesystypedef_test.py b/sources/shiboken6/tests/samplebinding/typesystypedef_test.py
index 5e54ef6ee..f7f5342ee 100644
--- a/sources/shiboken6/tests/samplebinding/typesystypedef_test.py
+++ b/sources/shiboken6/tests/samplebinding/typesystypedef_test.py
@@ -13,8 +13,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import (ValueWithUnitUser, ValueWithUnitDoubleInch,
-                    ValueWithUnitDoubleMillimeter)
+from sample import ValueWithUnitUser, ValueWithUnitDoubleInch
 
 
 class TypeSysTypeDefTest(unittest.TestCase):
diff --git a/sources/shiboken6/tests/samplebinding/unsafe_parent_test.py b/sources/shiboken6/tests/samplebinding/unsafe_parent_test.py
index dbc4097da..2a7e5cac7 100644
--- a/sources/shiboken6/tests/samplebinding/unsafe_parent_test.py
+++ b/sources/shiboken6/tests/samplebinding/unsafe_parent_test.py
@@ -15,6 +15,7 @@ init_paths()
 
 from sample import ObjectType
 
+
 class DerivedObjectType(ObjectType):
     def isPython(self):
         return True
@@ -22,12 +23,13 @@ class DerivedObjectType(ObjectType):
     def createChild(self, parent):
         return DerivedObjectType(parent)
 
+
 class ParentTest(unittest.TestCase):
 
     def testUunsafeParent(self):
         o = DerivedObjectType()
         o.callVirtualCreateChild()
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/useraddedctor_test.py b/sources/shiboken6/tests/samplebinding/useraddedctor_test.py
index 3aee8d6f7..45d4095b6 100644
--- a/sources/shiboken6/tests/samplebinding/useraddedctor_test.py
+++ b/sources/shiboken6/tests/samplebinding/useraddedctor_test.py
@@ -12,14 +12,15 @@ from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
-from sample import *
+from sample import Size
+
 
 class PointTest(unittest.TestCase):
     def testUsingSelfOnCtor(self):
         # This is a user added ctor and no errors should happen!
-        s = Size("oi")
+        s = Size("3x2")
         self.assertEqual(s.height(), 2)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/virtualdtor_test.py b/sources/shiboken6/tests/samplebinding/virtualdtor_test.py
index 69c3479c5..6be870269 100644
--- a/sources/shiboken6/tests/samplebinding/virtualdtor_test.py
+++ b/sources/shiboken6/tests/samplebinding/virtualdtor_test.py
@@ -16,10 +16,12 @@ init_paths()
 
 from sample import VirtualDtor
 
+
 class ExtendedVirtualDtor(VirtualDtor):
     def __init__(self):
         VirtualDtor.__init__(self)
 
+
 class VirtualDtorTest(unittest.TestCase):
     '''Test case for virtual destructor.'''
 
@@ -59,4 +61,3 @@ class VirtualDtorTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/virtualmethods_test.py b/sources/shiboken6/tests/samplebinding/virtualmethods_test.py
index 7be424e26..52dc66c90 100644
--- a/sources/shiboken6/tests/samplebinding/virtualmethods_test.py
+++ b/sources/shiboken6/tests/samplebinding/virtualmethods_test.py
@@ -14,10 +14,11 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import Point, Str, StrList, VirtualDaughter, VirtualMethods
 
 import warnings
 
+
 class ExtendedVirtualMethods(VirtualMethods):
     def __init__(self):
         VirtualMethods.__init__(self)
@@ -36,6 +37,7 @@ class ExtendedVirtualMethods(VirtualMethods):
         # check if recursion is caused by injected code that calls C++.
         return VirtualMethods.recursionOnModifiedVirtual(self, arg) + 10
 
+
 class ExtendedVirtualDaughter(VirtualDaughter):
     def __init__(self, name):
         VirtualDaughter.__init__(self, name)
@@ -45,6 +47,7 @@ class ExtendedVirtualDaughter(VirtualDaughter):
         self.grand_daughter_name_called = True
         return VirtualDaughter.name(self).prepend('Extended')
 
+
 class ExtendedExtendedVirtualDaughter(ExtendedVirtualDaughter):
     def __init__(self, name):
         ExtendedVirtualDaughter.__init__(self, name)
@@ -54,6 +57,7 @@ class ExtendedExtendedVirtualDaughter(ExtendedVirtualDaughter):
         self.grand_grand_daughter_name_called = True
         return ExtendedVirtualDaughter.name(self).prepend('Extended')
 
+
 class VirtualMethodsTest(unittest.TestCase):
     '''Test case for virtual methods'''
 
@@ -66,7 +70,8 @@ class VirtualMethodsTest(unittest.TestCase):
         gc.collect()
 
     def testReimplementedVirtualMethod0(self):
-        '''Test Python override of a virtual method with various different parameters is correctly called from C++.'''
+        '''Test Python override of a virtual method with various different parameters
+           is correctly called from C++.'''
         vm = VirtualMethods()
         evm = ExtendedVirtualMethods()
         pt = Point(1.1, 2.2)
@@ -120,6 +125,6 @@ class PrettyErrorMessageTest(unittest.TestCase):
         obj = ExtendedVirtualMethods()
         self.assertRaises(RuntimeWarning, obj.callStrListToStdList, StrList())
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/visibilitychange_test.py b/sources/shiboken6/tests/samplebinding/visibilitychange_test.py
index 1b810e839..becdf7423 100644
--- a/sources/shiboken6/tests/samplebinding/visibilitychange_test.py
+++ b/sources/shiboken6/tests/samplebinding/visibilitychange_test.py
@@ -11,17 +11,17 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
 
-from sample import *
+from sample import Base1, MDerived1
+
 
 class VisibilityChangeTest(unittest.TestCase):
 
     def testVisibilityChange(self):
         b1 = Base1()
-        b1.publicMethod() # ok...
+        b1.publicMethod()  # ok...
         d1 = MDerived1()
-        self.assertRaises(TypeError, d1.publicMethod);
+        self.assertRaises(TypeError, d1.publicMethod)
+
 
 if __name__ == '__main__':
     unittest.main()
-
-
diff --git a/sources/shiboken6/tests/samplebinding/voidholder_test.py b/sources/shiboken6/tests/samplebinding/voidholder_test.py
index 63882cc8a..186cb473e 100644
--- a/sources/shiboken6/tests/samplebinding/voidholder_test.py
+++ b/sources/shiboken6/tests/samplebinding/voidholder_test.py
@@ -16,6 +16,7 @@ init_paths()
 from sample import VoidHolder, Point
 from shiboken6 import Shiboken
 
+
 class VoidHolderTest(unittest.TestCase):
     '''Test case for void pointer manipulation.'''
 
@@ -44,6 +45,6 @@ class VoidHolderTest(unittest.TestCase):
         voidholder = VoidHolder()
         self.assertEqual(voidholder.voidPointer(), None)
 
+
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/shiboken6/tests/samplebinding/weakref_test.py b/sources/shiboken6/tests/samplebinding/weakref_test.py
index 317dfb53c..01c6d58d5 100644
--- a/sources/shiboken6/tests/samplebinding/weakref_test.py
+++ b/sources/shiboken6/tests/samplebinding/weakref_test.py
@@ -30,7 +30,7 @@ class WeakrefBasicTest(unittest.TestCase):
     def testBasic(self):
         '''ObjectType weakref'''
         obj = ObjectType()
-        ref = weakref.ref(obj, self.cb)
+        ref = weakref.ref(obj, self.cb)  # noqa: F841
         del obj
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
@@ -39,7 +39,7 @@ class WeakrefBasicTest(unittest.TestCase):
     def testPrivateDtor(self):
         '''PrivateDtor weakref'''
         obj = PrivateDtor.instance()
-        ref = weakref.ref(obj, self.cb)
+        ref = weakref.ref(obj, self.cb)  # noqa: F841
         del obj
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
diff --git a/sources/shiboken6/tests/samplebinding/writableclassdict_test.py b/sources/shiboken6/tests/samplebinding/writableclassdict_test.py
index e3ba10082..dfc962db9 100644
--- a/sources/shiboken6/tests/samplebinding/writableclassdict_test.py
+++ b/sources/shiboken6/tests/samplebinding/writableclassdict_test.py
@@ -13,7 +13,10 @@ init_paths()
 
 from sample import Point
 
-class ExtPoint(Point): pass
+
+class ExtPoint(Point):
+    pass
+
 
 class TestWritableClassDict(unittest.TestCase):
     def testSetattrOnClass(self):
@@ -29,5 +32,6 @@ class TestWritableClassDict(unittest.TestCase):
         pt = ExtPoint()
         self.assertEqual(pt.bar, 321)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/shibokenmodule/module_test.py b/sources/shiboken6/tests/shibokenmodule/module_test.py
index 9b9a5ad90..9f9f8f5a4 100644
--- a/sources/shiboken6/tests/shibokenmodule/module_test.py
+++ b/sources/shiboken6/tests/shibokenmodule/module_test.py
@@ -7,17 +7,19 @@ import unittest
 
 from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
-from shiboken_paths import init_paths
+from shiboken_paths import init_paths  # noqa: E402
 init_paths()
 
-from shiboken6 import Shiboken
-from sample import *
+from shiboken6 import Shiboken  # noqa: E402
+from sample import BlackBox, ObjectType, ObjectModel, ObjectView, Point  # noqa: E402
+
 
 class MultipleInherited (ObjectType, Point):
     def __init__(self):
         ObjectType.__init__(self)
         Point.__init__(self)
 
+
 class TestShiboken(unittest.TestCase):
     def testIsValid(self):
         self.assertTrue(Shiboken.isValid(object()))
@@ -43,6 +45,16 @@ class TestShiboken(unittest.TestCase):
         self.assertTrue(Shiboken.createdByPython(bb))
         bb.disposeObjectType(bb.keepObjectType(obj))
 
+    def testWrapInstancePreserveId(self):
+        """PYSIDE-31: Verify that wrapInstance() returns the existing wrapper
+           even if a base class type is specified."""
+        v = ObjectView()  # inherits ObjectType
+        addresses = Shiboken.getCppPointer(v)
+        self.assertTrue(addresses)
+        address = addresses[0]
+        wrapped = Shiboken.wrapInstance(address, ObjectType)
+        self.assertEqual(id(wrapped), id(v))
+
     def testIsOwnedByPython(self):
         obj = ObjectType()
         self.assertTrue(Shiboken.ownedByPython(obj))
@@ -55,7 +67,7 @@ class TestShiboken(unittest.TestCase):
         p = ObjectType()
         obj = ObjectType(p)
         obj2 = ObjectType(obj)
-        obj3 = ObjectType(obj)
+        obj3 = ObjectType(obj)  # noqa: F841
         self.assertEqual(Shiboken.dump(None), "Ordinary Python type.")
         Shiboken.dump(obj)
 
@@ -69,9 +81,9 @@ class TestShiboken(unittest.TestCase):
 
         # Don't crash even after deleting an object
         Shiboken.invalidate(obj)
-        Shiboken.dump(obj)  # deleted
-        Shiboken.dump(p)    # child deleted
-        Shiboken.dump(obj2) # parent deleted
+        Shiboken.dump(obj)   # deleted
+        Shiboken.dump(p)     # child deleted
+        Shiboken.dump(obj2)  # parent deleted
 
     def testDelete(self):
         obj = ObjectType()
diff --git a/sources/shiboken6/tests/smartbinding/CMakeLists.txt b/sources/shiboken6/tests/smartbinding/CMakeLists.txt
index b15967781..594744840 100644
--- a/sources/shiboken6/tests/smartbinding/CMakeLists.txt
+++ b/sources/shiboken6/tests/smartbinding/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(smart)
 
 set(smart_TYPESYSTEM
@@ -15,8 +18,10 @@ ${CMAKE_CURRENT_BINARY_DIR}/smart/smart_integer2_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/smart/sharedptr_integer2_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/smart/stdsharedptrtestbench_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/smart/stdsharedptrvirtualmethodtester_wrapper.cpp
+${CMAKE_CURRENT_BINARY_DIR}/smart/std_shared_ptr_double_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/smart/std_shared_ptr_integer_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/smart/std_shared_ptr_int_wrapper.cpp
+${CMAKE_CURRENT_BINARY_DIR}/smart/std_shared_ptr_std_string_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/smart/std_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/smart/std_optional_int_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/smart/std_optional_integer_wrapper.cpp
diff --git a/sources/shiboken6/tests/smartbinding/smart_pointer_test.py b/sources/shiboken6/tests/smartbinding/smart_pointer_test.py
index 1bec3a286..8d4272558 100644
--- a/sources/shiboken6/tests/smartbinding/smart_pointer_test.py
+++ b/sources/shiboken6/tests/smartbinding/smart_pointer_test.py
@@ -262,7 +262,7 @@ class SmartPointerTests(unittest.TestCase):
         self.assertTrue(five > four)
 
         self.assertRaises(NotImplementedError,
-                          lambda : Obj.createNullSharedPtrInteger() == four)
+                          lambda: Obj.createNullSharedPtrInteger() == four)
 
     def testSmartPointerObjectComparison(self):
         """Test a pointee class without comparison operators."""
diff --git a/sources/shiboken6/tests/smartbinding/std_optional_test.py b/sources/shiboken6/tests/smartbinding/std_optional_test.py
index be969d0f5..bee573548 100644
--- a/sources/shiboken6/tests/smartbinding/std_optional_test.py
+++ b/sources/shiboken6/tests/smartbinding/std_optional_test.py
@@ -2,7 +2,6 @@
 # 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 gc
 import os
 import sys
 import unittest
diff --git a/sources/shiboken6/tests/smartbinding/std_shared_ptr_test.py b/sources/shiboken6/tests/smartbinding/std_shared_ptr_test.py
index b4b9808c6..a37a307a5 100644
--- a/sources/shiboken6/tests/smartbinding/std_shared_ptr_test.py
+++ b/sources/shiboken6/tests/smartbinding/std_shared_ptr_test.py
@@ -2,7 +2,6 @@
 # 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 gc
 import os
 import sys
 import unittest
@@ -11,7 +10,7 @@ from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from shiboken_paths import init_paths
 init_paths()
-from smart import Integer, StdSharedPtrTestBench, StdSharedPtrVirtualMethodTester, std
+from smart import Integer, StdDoublePtr, StdSharedPtrTestBench, StdSharedPtrVirtualMethodTester, std
 
 
 def call_func_on_ptr(ptr):
@@ -28,6 +27,8 @@ class VirtualTester(StdSharedPtrVirtualMethodTester):
 class StdSharedPtrTests(unittest.TestCase):
     def testInteger(self):
         p = StdSharedPtrTestBench.createInteger()
+        # PYSIDE-2462: Ensure Integer's __dir__ entries in the pointer's
+        self.assertTrue("printInteger" in dir(p))
         StdSharedPtrTestBench.printInteger(p)
         self.assertTrue(p)
         call_func_on_ptr(p)
@@ -48,6 +49,24 @@ class StdSharedPtrTests(unittest.TestCase):
         self.assertFalse(np)
         p = StdSharedPtrTestBench.createInt()
         StdSharedPtrTestBench.printInt(p)
+        ip = std.StdIntPtr(42)
+        StdSharedPtrTestBench.printInt(ip)
+
+    def testDouble(self):
+        np = StdSharedPtrTestBench.createNullDouble()
+        StdSharedPtrTestBench.printDouble(np)
+        self.assertFalse(np)
+        p = StdSharedPtrTestBench.createDouble(67)
+        StdSharedPtrTestBench.printDouble(p)
+        dp = StdDoublePtr(42)
+        StdSharedPtrTestBench.printDouble(dp)
+
+    def testString(self):
+        np = StdSharedPtrTestBench.createNullString()
+        StdSharedPtrTestBench.printString(np)
+        self.assertFalse(np)
+        p = StdSharedPtrTestBench.createString("bla")
+        StdSharedPtrTestBench.printString(p)
 
     def testVirtuals(self):
         """Test whether code generating virtual function overrides is generated
diff --git a/sources/shiboken6/tests/smartbinding/std_unique_ptr_test.py b/sources/shiboken6/tests/smartbinding/std_unique_ptr_test.py
index 0f4729413..9c7ef2f01 100644
--- a/sources/shiboken6/tests/smartbinding/std_unique_ptr_test.py
+++ b/sources/shiboken6/tests/smartbinding/std_unique_ptr_test.py
@@ -2,7 +2,6 @@
 # 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 gc
 import os
 import sys
 import unittest
diff --git a/sources/shiboken6/tests/smartbinding/typesystem_smart.xml b/sources/shiboken6/tests/smartbinding/typesystem_smart.xml
index 261d5f15d..e479e4ddf 100644
--- a/sources/shiboken6/tests/smartbinding/typesystem_smart.xml
+++ b/sources/shiboken6/tests/smartbinding/typesystem_smart.xml
@@ -50,7 +50,7 @@
                             value-check-method="operator bool"
                             ref-count-method="use_count"
                             reset-method="reset"
-                            instantiations="Integer,int">
+                            instantiations="Integer,int=StdIntPtr,double=::StdDoublePtr,std::string">
             <include file-name="memory" location="global"/>
         </smart-pointer-type>
 
diff --git a/sources/shiboken6/tests/test_generator/CMakeLists.txt b/sources/shiboken6/tests/test_generator/CMakeLists.txt
index c6a7ec579..e1d078894 100644
--- a/sources/shiboken6/tests/test_generator/CMakeLists.txt
+++ b/sources/shiboken6/tests/test_generator/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)
 project(test_generator)
 
diff --git a/sources/shiboken6/tests/test_generator/run_test.cmake b/sources/shiboken6/tests/test_generator/run_test.cmake
index 34a821d80..37e40b993 100644
--- a/sources/shiboken6/tests/test_generator/run_test.cmake
+++ b/sources/shiboken6/tests/test_generator/run_test.cmake
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 # The tests are run through this script due to a limitation
 # on versions of CMake lesser than 2.8, that prevent setting
 # environment variables for tests from working.