Add files using upload-large-folder tool

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindATSPI2.cmake

@@ -0,0 +1,10 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+find_package(PkgConfig QUIET)
+
+pkg_check_modules(ATSPI2 IMPORTED_TARGET "atspi-2")
+
+if (NOT TARGET PkgConfig::ATSPI2)
+    set(ATSPI2_FOUND 0)
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindDB2.cmake

@@ -0,0 +1,65 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#.rst:
+# FindDB2
+# ---------
+#
+# Try to locate the db2 client library.
+# If found, this will define the following variables:
+#
+# ``DB2_FOUND``
+#     True if the db2 library is available
+# ``DB2_INCLUDE_DIRS``
+#     The db2 include directories
+# ``DB2_LIBRARIES``
+#     The db2 libraries for linking
+#
+# If ``DB2_FOUND`` is TRUE, it will also define the following
+# imported target:
+#
+# ``DB2::DB2``
+#     The db2 client library
+
+if (NOT DEFINED DB2_INCLUDE_DIR)
+  find_path(DB2_INCLUDE_DIR
+    NAMES sqlcli1.h
+    HINTS ENV DB2_HOME
+    PATH_SUFFIXES include)
+else()
+  find_path(DB2_INCLUDE_DIR
+    NAMES sqlcli1.h
+    HINTS ${DB2_INCLUDE_DIR})
+endif()
+
+if (NOT DEFINED DB2_LIBRARY_DIR)
+  find_library(DB2_LIBRARY
+    NAMES db2
+    HINTS ENV DB2LIB)
+else()
+  find_library(DB2_LIBRARY
+    NAMES db2
+    HINTS ${DB2_LIBRARY_DIR})
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(DB2 DEFAULT_MSG DB2_INCLUDE_DIR DB2_LIBRARY)
+
+if(DB2_FOUND)
+  set(DB2_INCLUDE_DIRS "${DB2_INCLUDE_DIR}")
+  set(DB2_LIBRARIES "${DB2_LIBRARY}")
+  if(NOT TARGET DB2::DB2)
+    add_library(DB2::DB2 UNKNOWN IMPORTED)
+    set_target_properties(DB2::DB2 PROPERTIES
+                          IMPORTED_LOCATION "${DB2_LIBRARIES}"
+                          INTERFACE_INCLUDE_DIRECTORIES "${DB2_INCLUDE_DIRS}")
+  endif()
+endif()
+
+mark_as_advanced(DB2_INCLUDE_DIR DB2_LIBRARY)
+
+include(FeatureSummary)
+set_package_properties(DB2 PROPERTIES
+  URL "https://www.ibm.com"
+  DESCRIPTION "IBM DB2 client library")
+

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindDirectFB.cmake

@@ -0,0 +1,10 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+find_package(PkgConfig QUIET)
+
+pkg_check_modules(DirectFB IMPORTED_TARGET "directfb")
+
+if (NOT TARGET PkgConfig::DirectFB)
+    set(DirectFB_FOUND 0)
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGLESv2.cmake

@@ -0,0 +1,90 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+include(CheckCXXSourceCompiles)
+
+# No library linkage is necessary to use GLESv2 with Emscripten. The headers are also
+# system headers, so we don't need to search for them.
+if(EMSCRIPTEN)
+    set(HAVE_GLESv2 ON)
+else()
+    find_library(GLESv2_LIBRARY NAMES GLESv2 OpenGLES)
+    find_path(GLESv2_INCLUDE_DIR NAMES "GLES2/gl2.h" "OpenGLES/ES2/gl.h" DOC "The OpenGLES 2 include path")
+    find_package(EGL)
+    set(_libraries "${CMAKE_REQUIRED_LIBRARIES}")
+    if(GLESv2_LIBRARY)
+        list(APPEND CMAKE_REQUIRED_LIBRARIES "${GLESv2_LIBRARY}")
+    endif ()
+    if(EGL_LIBRARY)
+        list(APPEND CMAKE_REQUIRED_LIBRARIES "${EGL_LIBRARY}")
+    endif()
+    set(_includes "${CMAKE_REQUIRED_INCLUDES}")
+    list(APPEND CMAKE_REQUIRED_INCLUDES "${GLESv2_INCLUDE_DIR}")
+
+    find_package(PlatformGraphics)
+    if(TARGET PlatformGraphics::PlatformGraphics)
+        platform_graphics_extend_check_cxx_source_required_variables()
+    endif()
+    check_cxx_source_compiles("
+#ifdef __APPLE__
+#  include <OpenGLES/ES2/gl.h>
+#else
+#  define GL_GLEXT_PROTOTYPES
+#  include <GLES2/gl2.h>
+#endif
+
+int main(int, char **) {
+    glUniform1f(1, GLfloat(1.0));
+    glClear(GL_COLOR_BUFFER_BIT);
+}" HAVE_GLESv2)
+
+    set(CMAKE_REQUIRED_LIBRARY "${_libraries}")
+    unset(_libraries)
+    set(CMAKE_REQUIRED_INCLUDES "${_includes}")
+    unset(_includes)
+    set(package_args GLESv2_INCLUDE_DIR GLESv2_LIBRARY HAVE_GLESv2)
+endif()
+
+# Framework handling partially inspired by FindGLUT.cmake.
+if(GLESv2_LIBRARY MATCHES "/([^/]+)\\.framework$")
+    # TODO: Might need to handle non .tbd suffixes, but didn't find an
+    # example like that.
+    # TODO: Might need to handle INTERFACE_INCLUDE_DIRECTORIES differently.
+    set(_library_imported_location "${GLESv2_LIBRARY}/${CMAKE_MATCH_1}.tbd")
+    if(NOT EXISTS "${_library_imported_location}")
+        set(_library_imported_location "")
+    endif()
+else()
+    set(_library_imported_location "${GLESv2_LIBRARY}")
+endif()
+set(GLESv2_LIBRARY "${_library_imported_location}")
+
+list(APPEND package_args HAVE_GLESv2)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GLESv2 DEFAULT_MSG ${package_args})
+
+mark_as_advanced(${package_args})
+
+if(GLESv2_FOUND AND NOT TARGET GLESv2::GLESv2)
+    if(EMSCRIPTEN OR IOS)
+        add_library(GLESv2::GLESv2 INTERFACE IMPORTED)
+        if(IOS)
+            # For simulator_and_device builds we can't specify the full library path, because
+            # it's specific to either the device or the simulator. Resort to passing a link
+            # flag instead.
+            target_link_libraries(GLESv2::GLESv2 INTERFACE "-framework OpenGLES")
+        endif()
+    else()
+        add_library(GLESv2::GLESv2 UNKNOWN IMPORTED)
+        set_target_properties(GLESv2::GLESv2 PROPERTIES
+            IMPORTED_LOCATION "${GLESv2_LIBRARY}"
+            INTERFACE_INCLUDE_DIRECTORIES "${GLESv2_INCLUDE_DIR}")
+
+        if(TARGET EGL::EGL)
+            target_link_libraries(GLESv2::GLESv2 INTERFACE "EGL::EGL")
+        elseif(EGL_LIBRARY)
+            target_link_libraries(GLESv2::GLESv2 INTERFACE "${EGL_LIBRARY}")
+        endif()
+    endif()
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGSSAPI.cmake

@@ -0,0 +1,58 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+find_package(PkgConfig QUIET)
+pkg_check_modules(PC_GSSAPI QUIET "krb5-gssapi")
+if (NOT PC_GSSAPI_FOUND)
+    pkg_check_modules(PC_GSSAPI QUIET "mit-krb5-gssapi")
+endif()
+
+find_path(GSSAPI_INCLUDE_DIRS
+          NAMES gssapi/gssapi.h
+          HINTS ${PC_GSSAPI_INCLUDEDIR}
+)
+
+# On macOS, vcpkg opts for finding frameworks LAST. This is generally fine;
+# however, in the case of GSSAPI, `usr/lib/libgssapi_krb5.tbd` which is a
+# symlink to `Kerberos.framework` misses a few symols, e.g.,
+# `___gss_c_nt_hostbased_service_oid_desc`, and it causes build failure.
+# So, we need to make sure that we find `GSS.framework`.
+set(gssapi_library_names
+  GSS    # framework
+  gss    # solaris
+  gssapi # FreeBSD
+  gssapi_krb5
+)
+if(APPLE)
+  list(REMOVE_ITEM gssapi_library_names "gssapi_krb5")
+endif()
+
+find_library(GSSAPI_LIBRARIES
+             NAMES
+             ${gssapi_library_names}
+             HINTS ${PC_GSSAPI_LIBDIR}
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GSSAPI DEFAULT_MSG GSSAPI_LIBRARIES GSSAPI_INCLUDE_DIRS)
+
+if(GSSAPI_FOUND AND NOT TARGET GSSAPI::GSSAPI)
+    if(GSSAPI_LIBRARIES MATCHES "/([^/]+)\\.framework$")
+        add_library(GSSAPI::GSSAPI INTERFACE IMPORTED)
+        set_target_properties(GSSAPI::GSSAPI PROPERTIES
+                              INTERFACE_LINK_LIBRARIES "${GSSAPI_LIBRARIES}")
+    else()
+      add_library(GSSAPI::GSSAPI UNKNOWN IMPORTED)
+      set_target_properties(GSSAPI::GSSAPI PROPERTIES
+                            IMPORTED_LOCATION "${GSSAPI_LIBRARIES}")
+    endif()
+
+    set_target_properties(GSSAPI::GSSAPI PROPERTIES
+                          INTERFACE_INCLUDE_DIRECTORIES "${GSSAPI_INCLUDE_DIRS}")
+endif()
+
+mark_as_advanced(GSSAPI_INCLUDE_DIRS GSSAPI_LIBRARIES)
+
+include(FeatureSummary)
+set_package_properties(GSSAPI PROPERTIES
+  DESCRIPTION "Generic Security Services Application Program Interface")

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGTK3.cmake

@@ -0,0 +1,15 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+find_package(PkgConfig QUIET)
+
+set(__gtk3_required_version "${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION}")
+if(__gtk3_required_version)
+    set(__gtk3_required_version " >= ${__gtk3_required_version}")
+endif()
+pkg_check_modules(GTK3 IMPORTED_TARGET "gtk+-3.0${__gtk3_required_version}")
+
+if (NOT TARGET PkgConfig::GTK3)
+    set(GTK3_FOUND 0)
+endif()
+unset(__gtk3_required_version)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindInterbase.cmake

@@ -0,0 +1,61 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#.rst:
+# FindInterbase
+# ---------
+#
+# Try to locate the Interbase client library.
+# If found, this will define the following variables:
+#
+# ``Interbase_FOUND``
+#     True if the Interbase library is available
+# ``Interbase_INCLUDE_DIR``
+#     The Interbase include directories
+# ``Interbase_LIBRARY``
+#     The Interbase libraries for linking
+#
+# If ``Interbase_FOUND`` is TRUE, it will also define the following
+# imported target:
+#
+# ``Interbase::Interbase``
+#     The Interbase client library
+
+if(NOT DEFINED Interbase_ROOT)
+    if(DEFINED ENV{Interbase_ROOT})
+        set(Interbase_ROOT "$ENV{Interbase_ROOT}")
+    endif()
+endif()
+
+find_path(Interbase_INCLUDE_DIR
+          NAMES ibase.h
+          HINTS "${Interbase_INCLUDEDIR}" "${Interbase_ROOT}/include"
+          PATH_SUFFIXES firebird
+)
+
+find_library(Interbase_LIBRARY
+             NAMES firebase_ms fbclient_ms fbclient gds
+             HINTS "${Interbase_LIBDIR}" "${Interbase_ROOT}/lib"
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Interbase DEFAULT_MSG Interbase_LIBRARY Interbase_INCLUDE_DIR)
+
+if(Interbase_FOUND)
+  set(Interbase_INCLUDE_DIRS "${Interbase_INCLUDE_DIR}")
+  set(Interbase_LIBRARIES "${Interbase_LIBRARY}")
+  if(NOT TARGET Interbase::Interbase)
+    add_library(Interbase::Interbase UNKNOWN IMPORTED)
+    set_target_properties(Interbase::Interbase PROPERTIES
+                          IMPORTED_LOCATION "${Interbase_LIBRARIES}"
+                          INTERFACE_INCLUDE_DIRECTORIES "${Interbase_INCLUDE_DIRS};")
+  endif()
+endif()
+
+mark_as_advanced(Interbase_INCLUDE_DIR Interbase_LIBRARY)
+
+include(FeatureSummary)
+set_package_properties(Interbase PROPERTIES
+  URL "https://www.embarcadero.com/products/interbase"
+  DESCRIPTION "Interbase client library")
+

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibb2.cmake

@@ -0,0 +1,40 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Blake2 contains a reference implementation, libb2 is a more efficient
+# implementation of a subset of Blake2 functions and should be preferred.
+# This Find module only searches for libb2 for that reason.
+
+if(TARGET Libb2::Libb2)
+    set(Libb2_FOUND TRUE)
+    return()
+endif()
+
+find_package(PkgConfig QUIET)
+
+if(PkgConfig_FOUND)
+    pkg_check_modules(Libb2 IMPORTED_TARGET "libb2")
+
+    if (TARGET PkgConfig::Libb2)
+        add_library(Libb2::Libb2 INTERFACE IMPORTED)
+        target_link_libraries(Libb2::Libb2 INTERFACE PkgConfig::Libb2)
+        set(Libb2_FOUND TRUE)
+    endif()
+else()
+    find_path(LIBB2_INCLUDE_DIR NAMES blake2.h)
+    find_library(LIBB2_LIBRARY NAMES b2)
+
+    if(LIBB2_LIBRARY AND LIBB2_INCLUDE_DIR)
+        add_library(Libb2::Libb2 UNKNOWN IMPORTED)
+        set_target_properties(Libb2::Libb2 PROPERTIES
+            IMPORTED_LOCATION ${LIBB2_LIBRARY}
+            INTERFACE_INCLUDE_DIRECTORIES ${LIBB2_INCLUDE_DIR}
+        )
+    endif()
+
+    include(FindPackageHandleStandardArgs)
+    find_package_handle_standard_args(Libb2 REQUIRED_VARS
+        LIBB2_LIBRARY
+        LIBB2_INCLUDE_DIR
+    )
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibmng.cmake

@@ -0,0 +1,38 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(TARGET Libmng::Libmng)
+    set(Libmng_FOUND TRUE)
+    return()
+endif()
+
+find_package(PkgConfig QUIET)
+
+if(PkgConfig_FOUND)
+    pkg_check_modules(Libmng IMPORTED_TARGET libmng)
+
+    if(TARGET PkgConfig::Libmng)
+        add_library(Libmng::Libmng INTERFACE IMPORTED)
+        target_link_libraries(Libmng::Libmng INTERFACE PkgConfig::Libmng)
+        set(Libmng_FOUND TRUE)
+    endif()
+endif()
+
+if(NOT TARGET Libmng::Libmng)
+    find_library(LIBMNG_LIBRARY NAMES mng)
+    find_path(LIBMNG_INCLUDE_DIR libmng.h)
+
+    if(LIBMNG_LIBRARY AND LIBMNG_INCLUDE_DIR)
+        add_library(Libmng::Libmng UNKNOWN IMPORTED)
+        set_target_properties(Libmng::Libmng PROPERTIES
+            IMPORTED_LOCATION ${LIBMNG_LIBRARY}
+            INTERFACE_INCLUDE_DIRECTORIES ${LIBMNG_INCLUDE_DIR}
+        )
+    endif()
+
+    include(FindPackageHandleStandardArgs)
+    find_package_handle_standard_args(Libmng REQUIRED_VARS
+        LIBMNG_LIBRARY
+        LIBMNG_INCLUDE_DIR
+    )
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibproxy.cmake

@@ -0,0 +1,10 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+find_package(PkgConfig QUIET)
+
+pkg_check_modules(Libproxy IMPORTED_TARGET "libproxy-1.0")
+
+if (NOT TARGET PkgConfig::Libproxy)
+    set(Libproxy_FOUND 0)
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibsystemd.cmake

@@ -0,0 +1,10 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+find_package(PkgConfig QUIET)
+
+pkg_check_modules(Libsystemd IMPORTED_TARGET "libsystemd")
+
+if (NOT TARGET PkgConfig::Libsystemd)
+    set(Libsystemd_FOUND 0)
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibudev.cmake

@@ -0,0 +1,10 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+find_package(PkgConfig QUIET)
+
+pkg_check_modules(Libudev IMPORTED_TARGET "libudev")
+
+if (NOT TARGET PkgConfig::Libudev)
+    set(Libudev_FOUND 0)
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMimer.cmake

@@ -0,0 +1,98 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# Copyright (C) 2022 Mimer Information Technology
+# SPDX-License-Identifier: BSD-3-Clause
+
+# FindMimer
+# ---------
+# Try to locate the Mimer SQL client library
+if(NOT DEFINED MimerSQL_ROOT)
+    if(DEFINED ENV{MIMERSQL_DEV_ROOT})
+        set(MimerSQL_ROOT "$ENV{MIMERSQL_DEV_ROOT}")
+    endif()
+endif()
+
+if(NOT DEFINED MimerSQL_ROOT)
+    find_package(PkgConfig QUIET)
+endif()
+if(PkgConfig_FOUND AND NOT DEFINED MimerSQL_ROOT)
+    pkg_check_modules(PC_Mimer QUIET mimcontrol)
+    set(MimerSQL_include_dir_hints "${PC_MimerSQL_INCLUDEDIR}")
+    set(MimerSQL_library_hints "${PC_MimerSQL_LIBDIR}")
+else()
+    if(DEFINED MimerSQL_ROOT)
+        if(WIN32)
+            set(MimerSQL_include_dir_hints "${MimerSQL_ROOT}\\include")
+            if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86|X86)$")
+                set(MimerSQL_library_hints "${MimerSQL_ROOT}\\lib\\x86")
+             elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(amd64|AMD64)$")
+                set(MimerSQL_library_hints "${MimerSQL_ROOT}\\lib\\amd64")
+            else()
+                set(MimerSQL_library_hints "")
+            endif()
+        else()
+            set(MimerSQL_include_dir_hints "${MimerSQL_ROOT}/include")
+            set(MimerSQL_library_hints "${MimerSQL_ROOT}/lib")
+        endif()
+    else()
+        if(WIN32)
+            set(MimerSQL_include_dir_hints "C:\\MimerSQLDev\\include")
+            if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86|X86)$")
+                set(MimerSQL_library_hints "C:\\MimerSQLDev\\lib\\x86")
+            elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(amd64|AMD64)$")
+                set(MimerSQL_library_hints "C:\\MimerSQLDev\\lib\\amd64")
+            else()
+                set(MimerSQL_library_hints "")
+            endif()
+        elseif(APPLE AND ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+            set(MimerSQL_library_hints "/usr/local/lib")
+            set(MimerSQL_include_dir_hints "/usr/local/include")
+        else()
+            set(MimerSQL_include_dir_hints "")
+            set(MimerSQL_library_hints "")
+        endif()
+    endif()
+endif()
+
+find_path(Mimer_INCLUDE_DIR
+    NAMES mimerapi.h
+    HINTS ${MimerSQL_include_dir_hints})
+
+if(WIN32)
+  if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86|X86)$")
+    set(MIMER_LIBS_NAMES mimapi32)
+  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(amd64|AMD64)$")
+    set(MIMER_LIBS_NAMES mimapi64)
+  endif()
+else()
+  set(MIMER_LIBS_NAMES mimerapi)
+endif()
+
+find_library(Mimer_LIBRARIES
+    NAMES ${MIMER_LIBS_NAMES}
+    HINTS ${MimerSQL_library_hints})
+
+include(FindPackageHandleStandardArgs)
+
+find_package_handle_standard_args(Mimer
+    REQUIRED_VARS Mimer_LIBRARIES Mimer_INCLUDE_DIR)
+
+
+
+# Now try to get the include and library path.
+if(Mimer_FOUND)
+  set(Mimer_INCLUDE_DIRS ${Mimer_INCLUDE_DIR})
+  set(Mimer_LIBRARY_DIRS ${Mimer_LIBRARIES})
+  if (NOT TARGET MimerSQL::MimerSQL)
+    add_library(MimerSQL::MimerSQL UNKNOWN IMPORTED)
+    set_target_properties(MimerSQL::MimerSQL PROPERTIES
+      IMPORTED_LOCATION "${Mimer_LIBRARY_DIRS}"
+      INTERFACE_INCLUDE_DIRECTORIES "${Mimer_INCLUDE_DIRS}")
+  endif ()
+endif()
+
+mark_as_advanced(Mimer_INCLUDE_DIR Mimer_LIBRARIES)
+
+include(FeatureSummary)
+set_package_properties(MimerSQL PROPERTIES
+  URL "https://www.mimer.com"
+  DESCRIPTION "Mimer client library")

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMtdev.cmake

@@ -0,0 +1,10 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+find_package(PkgConfig QUIET)
+
+pkg_check_modules(Mtdev IMPORTED_TARGET "mtdev")
+
+if (NOT TARGET PkgConfig::Mtdev)
+    set(Mtdev_FOUND 0)
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMySQL.cmake

@@ -0,0 +1,104 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#.rst:
+# FindMySQL
+# ---------
+#
+# Try to locate the mysql client library.
+#
+# By default, pkg-config is used, if available.
+# If pkg-config is not available or if you want to disable it, set the ``MySQL_ROOT`` variable.
+# The following variables can be set to control the behavior of this find module.
+#
+# ``MySQL_ROOT``
+#     The root directory of the mysql client library's installation.
+# ``MySQL_INCLUDE_DIR``
+#     The directory containing the include files of the mysql client library.
+#     If not set, the directory is detected within ``MySQL_ROOT`` using find_path.
+# ``MySQL_LIBRARY_DIR``
+#     The directory containing the binaries of the mysql client library.
+#     This is used to detect ``MySQL_LIBRARY`` and passed as HINT to find_library.
+# ``MySQL_LIBRARY``
+#     The file path to the mysql client library.
+# ``MySQL_LIBRARY_DEBUG``
+#     The file path to the mysql client library for the DEBUG configuration.
+#
+# If the mysql client library is found, this will define the following variables:
+#
+# ``MySQL_FOUND``
+#     True if the mysql library is available
+# ``MySQL_INCLUDE_DIRS``
+#     The mysql include directories
+# ``MySQL_LIBRARIES``
+#     The mysql libraries for linking
+#
+# If ``MySQL_FOUND`` is TRUE, it will also define the following
+# imported target:
+#
+# ``MySQL::MySQL``
+#     The mysql client library
+
+if(NOT DEFINED MySQL_ROOT)
+    if(DEFINED ENV{MySQL_ROOT})
+        set(MySQL_ROOT "$ENV{MySQL_ROOT}")
+    else()
+        find_package(PkgConfig QUIET)
+    endif()
+endif()
+if(PkgConfig_FOUND AND NOT DEFINED MySQL_ROOT)
+    pkg_check_modules(PC_MySQL QUIET "mysqlclient")
+    set(MySQL_include_dir_hints ${PC_MySQL_INCLUDEDIR})
+    set(MySQL_library_hints ${PC_MySQL_LIBDIR})
+    set(MySQL_library_hints_debug "")
+else()
+    set(MySQL_include_dir_hints "${MySQL_ROOT}" "${MySQL_ROOT}/include")
+    if(NOT DEFINED MySQL_LIBRARY_DIR)
+        set(MySQL_LIBRARY_DIR "${MySQL_ROOT}/lib")
+    endif()
+    set(MySQL_library_hints "${MySQL_LIBRARY_DIR}")
+    set(MySQL_library_hints_debug "${MySQL_LIBRARY_DIR}/debug")
+endif()
+
+find_path(MySQL_INCLUDE_DIR
+          NAMES mysql.h
+          HINTS "${MySQL_include_dir_hints}"
+          PATH_SUFFIXES mysql mariadb)
+
+find_library(MySQL_LIBRARY
+             NO_PACKAGE_ROOT_PATH
+             NAMES libmysql mysql mysqlclient libmariadb mariadb
+             HINTS ${MySQL_library_hints})
+
+if(MySQL_library_hints_debug)
+    find_library(MySQL_LIBRARY_DEBUG
+                 NO_PACKAGE_ROOT_PATH
+                 NAMES libmysql mysql mysqlclient libmariadb mariadb
+                 HINTS ${MySQL_library_hints_debug})
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(MySQL DEFAULT_MSG MySQL_LIBRARY MySQL_INCLUDE_DIR)
+
+if(MySQL_FOUND)
+  set(MySQL_INCLUDE_DIRS "${MySQL_INCLUDE_DIR}")
+  set(MySQL_LIBRARIES "${MySQL_LIBRARY}")
+  if(NOT TARGET MySQL::MySQL)
+    add_library(MySQL::MySQL UNKNOWN IMPORTED)
+    set_target_properties(MySQL::MySQL PROPERTIES
+                          IMPORTED_LOCATION "${MySQL_LIBRARIES}"
+                          INTERFACE_INCLUDE_DIRECTORIES "${MySQL_INCLUDE_DIRS}")
+    if(MySQL_LIBRARY_DEBUG)
+      set_target_properties(MySQL::MySQL PROPERTIES
+                            IMPORTED_LOCATION_DEBUG "${MySQL_LIBRARY_DEBUG}")
+    endif()
+  endif()
+endif()
+
+mark_as_advanced(MySQL_INCLUDE_DIR MySQL_LIBRARY)
+
+include(FeatureSummary)
+set_package_properties(MySQL PROPERTIES
+  URL "https://www.mysql.com"
+  DESCRIPTION "MySQL client library")
+

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindOracle.cmake

@@ -0,0 +1,62 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#.rst:
+# FindOracle
+# ---------
+#
+# Try to locate the oracle client library.
+# If found, this will define the following variables:
+#
+# ``Oracle_FOUND``
+#     True if the oracle library is available
+# ``Oracle_INCLUDE_DIRS``
+#     The oracle include directories
+# ``Oracle_LIBRARIES``
+#     The oracle libraries for linking
+#
+# If ``Oracle_FOUND`` is TRUE, it will also define the following
+# imported target:
+#
+# ``Oracle::Oracle``
+#     The oracle instant client library
+
+if(NOT DEFINED Oracle_ROOT)
+    if(DEFINED ENV{Oracle_ROOT})
+        set(Oracle_ROOT "$ENV{Oracle_ROOT}")
+    endif()
+endif()
+
+find_path(Oracle_INCLUDE_DIR
+  NAMES oci.h
+  HINTS ${Oracle_INCLUDE_DIR} "${Oracle_ROOT}" "${Oracle_ROOT}/include" "${Oracle_ROOT}/sdk/include"
+)
+
+set(ORACLE_OCI_NAMES clntsh ociei oraociei12 oci)
+
+find_library(Oracle_LIBRARY
+  NAMES ${ORACLE_OCI_NAMES}
+  HINTS ${Oracle_LIBRARY_DIR} "${Oracle_ROOT}" "${Oracle_ROOT}/lib" "${Oracle_ROOT}/sdk/lib"
+  PATH_SUFFIXES msvc
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Oracle DEFAULT_MSG Oracle_LIBRARY Oracle_INCLUDE_DIR)
+
+if(Oracle_FOUND)
+  set(Oracle_INCLUDE_DIRS "${Oracle_INCLUDE_DIR}")
+  set(Oracle_LIBRARIES "${Oracle_LIBRARY}")
+  if(NOT TARGET Oracle::OCI)
+    add_library(Oracle::OCI UNKNOWN IMPORTED)
+    set_target_properties(Oracle::OCI PROPERTIES
+                        IMPORTED_LOCATION "${Oracle_LIBRARIES}"
+                        INTERFACE_INCLUDE_DIRECTORIES "${Oracle_INCLUDE_DIRS}")
+  endif()
+endif()
+
+mark_as_advanced(Oracle_INCLUDE_DIR Oracle_LIBRARY)
+
+include(FeatureSummary)
+set_package_properties(Oracle PROPERTIES
+  URL "https://www.oracle.com"
+  DESCRIPTION "Oracle client library")

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindPPS.cmake

@@ -0,0 +1,24 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Find the PPS library
+
+# Will make the target PPS::PPS available when found.
+if(TARGET PPS::PPS)
+    set(PPS_FOUND TRUE)
+    return()
+endif()
+
+find_library(PPS_LIBRARY NAMES "pps")
+find_path(PPS_INCLUDE_DIR NAMES "sys/pps.h" DOC "The PPS Include path")
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(PPS DEFAULT_MSG PPS_INCLUDE_DIR PPS_LIBRARY)
+
+mark_as_advanced(PPS_INCLUDE_DIR PPS_LIBRARY)
+
+if(PPS_FOUND)
+    add_library(PPS::PPS INTERFACE IMPORTED)
+    target_link_libraries(PPS::PPS INTERFACE "${PPS_LIBRARY}")
+    target_include_directories(PPS::PPS INTERFACE "${PPS_INCLUDE_DIR}")
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindPostgreSQL.cmake

@@ -0,0 +1,321 @@
+# Copyright (C) 2000-2022 Kitware, Inc. and Contributors.
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#[=======================================================================[.rst:
+FindPostgreSQL
+--------------
+
+Find the PostgreSQL installation.
+
+IMPORTED Targets
+^^^^^^^^^^^^^^^^
+
+.. versionadded:: 3.14
+
+This module defines :prop_tgt:`IMPORTED` target ``PostgreSQL::PostgreSQL``
+if PostgreSQL has been found.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module will set the following variables in your project:
+
+``PostgreSQL_FOUND``
+  True if PostgreSQL is found.
+``PostgreSQL_LIBRARIES``
+  the PostgreSQL libraries needed for linking
+``PostgreSQL_INCLUDE_DIRS``
+  the directories of the PostgreSQL headers
+``PostgreSQL_LIBRARY_DIRS``
+  the link directories for PostgreSQL libraries
+``PostgreSQL_VERSION_STRING``
+  the version of PostgreSQL found
+``PostgreSQL_TYPE_INCLUDE_DIR``
+  the directories of the PostgreSQL server headers
+
+Components
+^^^^^^^^^^
+
+This module contains additional ``Server`` component, that forcibly checks
+for the presence of server headers. Note that ``PostgreSQL_TYPE_INCLUDE_DIR``
+is set regardless of the presence of the ``Server`` component in find_package call.
+
+#]=======================================================================]
+
+# ----------------------------------------------------------------------------
+# History:
+# This module is derived from the module originally found in the VTK source tree.
+#
+# ----------------------------------------------------------------------------
+# Note:
+# PostgreSQL_ADDITIONAL_VERSIONS is a variable that can be used to set the
+# version number of the implementation of PostgreSQL.
+# In Windows the default installation of PostgreSQL uses that as part of the path.
+# E.g C:\Program Files\PostgreSQL\8.4.
+# Currently, the following version numbers are known to this module:
+# "11" "10" "9.6" "9.5" "9.4" "9.3" "9.2" "9.1" "9.0" "8.4" "8.3" "8.2" "8.1" "8.0"
+#
+# To use this variable just do something like this:
+# set(PostgreSQL_ADDITIONAL_VERSIONS "9.2" "8.4.4")
+# before calling find_package(PostgreSQL) in your CMakeLists.txt file.
+# This will mean that the versions you set here will be found first in the order
+# specified before the default ones are searched.
+#
+# ----------------------------------------------------------------------------
+# You may need to manually set:
+#  PostgreSQL_INCLUDE_DIR  - the path to where the PostgreSQL include files are.
+#  PostgreSQL_LIBRARY_DIR  - The path to where the PostgreSQL library files are.
+# If FindPostgreSQL.cmake cannot find the include files or the library files.
+#
+# ----------------------------------------------------------------------------
+# The following variables are set if PostgreSQL is found:
+#  PostgreSQL_FOUND         - Set to true when PostgreSQL is found.
+#  PostgreSQL_INCLUDE_DIRS  - Include directories for PostgreSQL
+#  PostgreSQL_LIBRARY_DIRS  - Link directories for PostgreSQL libraries
+#  PostgreSQL_LIBRARIES     - The PostgreSQL libraries.
+#
+# The ``PostgreSQL::PostgreSQL`` imported target is also created.
+#
+# ----------------------------------------------------------------------------
+# If you have installed PostgreSQL in a non-standard location.
+# (Please note that in the following comments, it is assumed that <Your Path>
+# points to the root directory of the include directory of PostgreSQL.)
+# Then you have three options.
+# 1) After CMake runs, set PostgreSQL_INCLUDE_DIR to <Your Path>/include and
+#    PostgreSQL_LIBRARY_DIR to wherever the library pq (or libpq in windows) is
+# 2) Use CMAKE_INCLUDE_PATH to set a path to <Your Path>/PostgreSQL<-version>. This will allow find_path()
+#    to locate PostgreSQL_INCLUDE_DIR by utilizing the PATH_SUFFIXES option. e.g. In your CMakeLists.txt file
+#    set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "<Your Path>/include")
+# 3) Set an environment variable called ${PostgreSQL_ROOT} that points to the root of where you have
+#    installed PostgreSQL, e.g. <Your Path>.
+#
+# ----------------------------------------------------------------------------
+
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
+  include("${CMAKE_ROOT}/Modules/FindPostgreSQL.cmake")
+  return()
+endif()
+
+cmake_policy(PUSH)
+cmake_policy(SET CMP0057 NEW) # if IN_LIST
+if(POLICY CMP0159)
+  cmake_policy(SET CMP0159 NEW)
+endif()
+
+set(PostgreSQL_INCLUDE_PATH_DESCRIPTION "top-level directory containing the PostgreSQL include directories. E.g /usr/local/include/PostgreSQL/8.4 or C:/Program Files/PostgreSQL/8.4/include")
+set(PostgreSQL_INCLUDE_DIR_MESSAGE "Set the PostgreSQL_INCLUDE_DIR cmake cache entry to the ${PostgreSQL_INCLUDE_PATH_DESCRIPTION}")
+set(PostgreSQL_LIBRARY_PATH_DESCRIPTION "top-level directory containing the PostgreSQL libraries.")
+set(PostgreSQL_LIBRARY_DIR_MESSAGE "Set the PostgreSQL_LIBRARY_DIR cmake cache entry to the ${PostgreSQL_LIBRARY_PATH_DESCRIPTION}")
+set(PostgreSQL_ROOT_DIR_MESSAGE "Set the PostgreSQL_ROOT system variable to where PostgreSQL is found on the machine E.g C:/Program Files/PostgreSQL/8.4")
+
+
+set(PostgreSQL_KNOWN_VERSIONS ${PostgreSQL_ADDITIONAL_VERSIONS}
+    "13" "12" "11" "10" "9.6" "9.5" "9.4" "9.3" "9.2" "9.1" "9.0" "8.4" "8.3" "8.2" "8.1" "8.0")
+
+# Define additional search paths for root directories.
+set( PostgreSQL_ROOT_DIRECTORIES
+   ENV PostgreSQL_ROOT
+   ${PostgreSQL_ROOT}
+)
+foreach(suffix ${PostgreSQL_KNOWN_VERSIONS})
+  if(WIN32)
+    list(APPEND PostgreSQL_LIBRARY_ADDITIONAL_SEARCH_SUFFIXES
+        "PostgreSQL/${suffix}/lib")
+    list(APPEND PostgreSQL_INCLUDE_ADDITIONAL_SEARCH_SUFFIXES
+        "PostgreSQL/${suffix}/include")
+    list(APPEND PostgreSQL_TYPE_ADDITIONAL_SEARCH_SUFFIXES
+        "PostgreSQL/${suffix}/include/server")
+  endif()
+  if(UNIX)
+    list(APPEND PostgreSQL_LIBRARY_ADDITIONAL_SEARCH_SUFFIXES
+        "postgresql${suffix}"
+        "pgsql-${suffix}/lib")
+    list(APPEND PostgreSQL_INCLUDE_ADDITIONAL_SEARCH_SUFFIXES
+        "postgresql${suffix}"
+        "postgresql/${suffix}"
+        "pgsql-${suffix}/include")
+    list(APPEND PostgreSQL_TYPE_ADDITIONAL_SEARCH_SUFFIXES
+        "postgresql${suffix}/server"
+        "postgresql/${suffix}/server"
+        "pgsql-${suffix}/include/server")
+  endif()
+endforeach()
+
+#
+# Look for an installation.
+#
+find_path(PostgreSQL_INCLUDE_DIR
+  NAMES libpq-fe.h
+  PATHS
+   # Look in other places.
+   ${PostgreSQL_ROOT_DIRECTORIES}
+  PATH_SUFFIXES
+    pgsql
+    postgresql
+    include
+    ${PostgreSQL_INCLUDE_ADDITIONAL_SEARCH_SUFFIXES}
+  # Help the user find it if we cannot.
+  DOC "The ${PostgreSQL_INCLUDE_DIR_MESSAGE}"
+)
+
+find_path(PostgreSQL_TYPE_INCLUDE_DIR
+  NAMES catalog/pg_type.h
+  PATHS
+   # Look in other places.
+   ${PostgreSQL_ROOT_DIRECTORIES}
+  PATH_SUFFIXES
+    postgresql
+    pgsql/server
+    postgresql/server
+    include/server
+    ${PostgreSQL_TYPE_ADDITIONAL_SEARCH_SUFFIXES}
+  # Help the user find it if we cannot.
+  DOC "The ${PostgreSQL_INCLUDE_DIR_MESSAGE}"
+)
+
+# The PostgreSQL library.
+set (PostgreSQL_LIBRARY_TO_FIND pq)
+# Setting some more prefixes for the library
+set (PostgreSQL_LIB_PREFIX "")
+if ( WIN32 )
+  set (PostgreSQL_LIB_PREFIX ${PostgreSQL_LIB_PREFIX} "lib")
+  set (PostgreSQL_LIBRARY_TO_FIND ${PostgreSQL_LIB_PREFIX}${PostgreSQL_LIBRARY_TO_FIND})
+endif()
+
+function(__postgresql_find_library _name)
+  find_library(${_name}
+   NAMES ${ARGN}
+   PATHS
+     ${PostgreSQL_ROOT_DIRECTORIES}
+   PATH_SUFFIXES
+     lib
+     ${PostgreSQL_LIBRARY_ADDITIONAL_SEARCH_SUFFIXES}
+   # Help the user find it if we cannot.
+   DOC "The ${PostgreSQL_LIBRARY_DIR_MESSAGE}"
+  )
+endfunction()
+
+# For compatibility with versions prior to this multi-config search, honor
+# any PostgreSQL_LIBRARY that is already specified and skip the search.
+if(PostgreSQL_LIBRARY)
+  set(PostgreSQL_LIBRARIES "${PostgreSQL_LIBRARY}")
+  get_filename_component(PostgreSQL_LIBRARY_DIR "${PostgreSQL_LIBRARY}" PATH)
+else()
+  __postgresql_find_library(PostgreSQL_LIBRARY_RELEASE ${PostgreSQL_LIBRARY_TO_FIND})
+  __postgresql_find_library(PostgreSQL_LIBRARY_DEBUG ${PostgreSQL_LIBRARY_TO_FIND}d)
+  include(SelectLibraryConfigurations)
+  select_library_configurations(PostgreSQL)
+  mark_as_advanced(PostgreSQL_LIBRARY_RELEASE PostgreSQL_LIBRARY_DEBUG)
+  if(PostgreSQL_LIBRARY_RELEASE)
+    get_filename_component(PostgreSQL_LIBRARY_DIR "${PostgreSQL_LIBRARY_RELEASE}" PATH)
+  elseif(PostgreSQL_LIBRARY_DEBUG)
+    get_filename_component(PostgreSQL_LIBRARY_DIR "${PostgreSQL_LIBRARY_DEBUG}" PATH)
+  else()
+    set(PostgreSQL_LIBRARY_DIR "")
+  endif()
+endif()
+
+if (PostgreSQL_INCLUDE_DIR)
+  # Some platforms include multiple pg_config.hs for multi-lib configurations
+  # This is a temporary workaround.  A better solution would be to compile
+  # a dummy c file and extract the value of the symbol.
+  file(GLOB _PG_CONFIG_HEADERS "${PostgreSQL_INCLUDE_DIR}/pg_config*.h")
+  foreach(_PG_CONFIG_HEADER ${_PG_CONFIG_HEADERS})
+    if(EXISTS "${_PG_CONFIG_HEADER}")
+      file(STRINGS "${_PG_CONFIG_HEADER}" pgsql_version_str
+           REGEX "^#define[\t ]+PG_VERSION_NUM[\t ]+.*")
+      if(pgsql_version_str)
+        string(REGEX REPLACE "^#define[\t ]+PG_VERSION_NUM[\t ]+([0-9]*).*"
+               "\\1" _PostgreSQL_VERSION_NUM "${pgsql_version_str}")
+        break()
+      endif()
+    endif()
+  endforeach()
+  if (_PostgreSQL_VERSION_NUM)
+    # 9.x and older encoding
+    if (_PostgreSQL_VERSION_NUM LESS 100000)
+      math(EXPR _PostgreSQL_major_version "${_PostgreSQL_VERSION_NUM} / 10000")
+      math(EXPR _PostgreSQL_minor_version "${_PostgreSQL_VERSION_NUM} % 10000 / 100")
+      math(EXPR _PostgreSQL_patch_version "${_PostgreSQL_VERSION_NUM} % 100")
+      set(PostgreSQL_VERSION_STRING "${_PostgreSQL_major_version}.${_PostgreSQL_minor_version}.${_PostgreSQL_patch_version}")
+      unset(_PostgreSQL_major_version)
+      unset(_PostgreSQL_minor_version)
+      unset(_PostgreSQL_patch_version)
+    else ()
+      math(EXPR _PostgreSQL_major_version "${_PostgreSQL_VERSION_NUM} / 10000")
+      math(EXPR _PostgreSQL_minor_version "${_PostgreSQL_VERSION_NUM} % 10000")
+      set(PostgreSQL_VERSION_STRING "${_PostgreSQL_major_version}.${_PostgreSQL_minor_version}")
+      unset(_PostgreSQL_major_version)
+      unset(_PostgreSQL_minor_version)
+    endif ()
+  else ()
+    foreach(_PG_CONFIG_HEADER ${_PG_CONFIG_HEADERS})
+      if(EXISTS "${_PG_CONFIG_HEADER}")
+        file(STRINGS "${_PG_CONFIG_HEADER}" pgsql_version_str
+             REGEX "^#define[\t ]+PG_VERSION[\t ]+\".*\"")
+        if(pgsql_version_str)
+          string(REGEX REPLACE "^#define[\t ]+PG_VERSION[\t ]+\"([^\"]*)\".*"
+                 "\\1" PostgreSQL_VERSION_STRING "${pgsql_version_str}")
+          break()
+        endif()
+      endif()
+    endforeach()
+  endif ()
+  unset(_PostgreSQL_VERSION_NUM)
+  unset(pgsql_version_str)
+endif()
+
+if("Server" IN_LIST PostgreSQL_FIND_COMPONENTS)
+  set(PostgreSQL_Server_FOUND TRUE)
+  if(NOT PostgreSQL_TYPE_INCLUDE_DIR)
+    set(PostgreSQL_Server_FOUND FALSE)
+  endif()
+endif()
+
+# Did we find anything?
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(PostgreSQL
+                                  REQUIRED_VARS PostgreSQL_LIBRARY PostgreSQL_INCLUDE_DIR
+                                  HANDLE_COMPONENTS
+                                  VERSION_VAR PostgreSQL_VERSION_STRING)
+set(PostgreSQL_FOUND  ${POSTGRESQL_FOUND})
+
+function(__postgresql_import_library _target _var _config)
+  if(_config)
+    set(_config_suffix "_${_config}")
+  else()
+    set(_config_suffix "")
+  endif()
+
+  set(_lib "${${_var}${_config_suffix}}")
+  if(EXISTS "${_lib}")
+    if(_config)
+      set_property(TARGET ${_target} APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS ${_config})
+    endif()
+    set_target_properties(${_target} PROPERTIES
+      IMPORTED_LOCATION${_config_suffix} "${_lib}")
+  endif()
+endfunction()
+
+# Now try to get the include and library path.
+if(PostgreSQL_FOUND)
+  set(PostgreSQL_INCLUDE_DIRS ${PostgreSQL_INCLUDE_DIR})
+  if(PostgreSQL_TYPE_INCLUDE_DIR)
+    list(APPEND PostgreSQL_INCLUDE_DIRS ${PostgreSQL_TYPE_INCLUDE_DIR})
+  endif()
+  set(PostgreSQL_LIBRARY_DIRS ${PostgreSQL_LIBRARY_DIR})
+  if (NOT TARGET PostgreSQL::PostgreSQL)
+    add_library(PostgreSQL::PostgreSQL UNKNOWN IMPORTED)
+    set_target_properties(PostgreSQL::PostgreSQL PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${PostgreSQL_INCLUDE_DIRS}")
+    __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "")
+    __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "RELEASE")
+    __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "DEBUG")
+  endif ()
+endif()
+
+mark_as_advanced(PostgreSQL_INCLUDE_DIR PostgreSQL_TYPE_INCLUDE_DIR)
+
+cmake_policy(POP)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindRenderDoc.cmake

@@ -0,0 +1,20 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(WIN32 OR UNIX)
+    find_path(RenderDoc_INCLUDE_DIR
+        NAMES renderdoc_app.h)
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(RenderDoc
+    DEFAULT_MSG
+    RenderDoc_INCLUDE_DIR)
+
+mark_as_advanced(RenderDoc_INCLUDE_DIR)
+
+if(RenderDoc_FOUND AND NOT TARGET RenderDoc::RenderDoc)
+    add_library(RenderDoc::RenderDoc INTERFACE IMPORTED)
+    set_target_properties(RenderDoc::RenderDoc PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${RenderDoc_INCLUDE_DIR}")
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindSlog2.cmake

@@ -0,0 +1,24 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Find the Slog2 library
+
+# Will make the target Slog2::Slog2 available when found.
+if(TARGET Slog2::Slog2)
+    set(Slog2_FOUND TRUE)
+    return()
+endif()
+
+find_library(Slog2_LIBRARY NAMES "slog2")
+find_path(Slog2_INCLUDE_DIR NAMES "sys/slog2.h" DOC "The Slog2 Include path")
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Slog2 DEFAULT_MSG Slog2_INCLUDE_DIR Slog2_LIBRARY)
+
+mark_as_advanced(Slog2_INCLUDE_DIR Slog2_LIBRARY)
+
+if(Slog2_FOUND)
+    add_library(Slog2::Slog2 INTERFACE IMPORTED)
+    target_link_libraries(Slog2::Slog2 INTERFACE ${Slog2_LIBRARY})
+    target_include_directories(Slog2::Slog2 INTERFACE ${Slog2_INCLUDE_DIR})
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindTslib.cmake

@@ -0,0 +1,10 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+find_package(PkgConfig QUIET)
+
+pkg_check_modules(Tslib IMPORTED_TARGET "tslib")
+
+if (NOT TARGET PkgConfig::Tslib)
+    set(Tslib_FOUND 0)
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapAtomic.cmake

@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapAtomic::WrapAtomic)
+    set(WrapAtomic_FOUND ON)
+    return()
+endif()
+
+include(CheckCXXSourceCompiles)
+
+set (atomic_test_sources "#include <atomic>
+#include <cstdint>
+
+int main(int, char **)
+{
+    volatile std::atomic<char>    size_1;
+    volatile std::atomic<short>   size_2;
+    volatile std::atomic<int>     size_4;
+    volatile std::atomic<int64_t> size_8;
+
+    ++size_1;
+    ++size_2;
+    ++size_4;
+    ++size_8;
+
+    (void)size_1.load(std::memory_order_relaxed);
+    (void)size_2.load(std::memory_order_relaxed);
+    (void)size_4.load(std::memory_order_relaxed);
+    (void)size_8.load(std::memory_order_relaxed);
+
+    return 0;
+}")
+
+check_cxx_source_compiles("${atomic_test_sources}" HAVE_STDATOMIC)
+if(NOT HAVE_STDATOMIC)
+    set(_req_libraries "${CMAKE_REQUIRED_LIBRARIES}")
+    set(atomic_LIB "-latomic")
+    set(CMAKE_REQUIRED_LIBRARIES ${atomic_LIB})
+    check_cxx_source_compiles("${atomic_test_sources}" HAVE_STDATOMIC_WITH_LIB)
+    set(CMAKE_REQUIRED_LIBRARIES "${_req_libraries}")
+endif()
+
+add_library(WrapAtomic::WrapAtomic INTERFACE IMPORTED)
+if(HAVE_STDATOMIC_WITH_LIB)
+    # atomic_LIB is already found above.
+    target_link_libraries(WrapAtomic::WrapAtomic INTERFACE ${atomic_LIB})
+endif()
+
+set(WrapAtomic_FOUND 1)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapAtomic DEFAULT_MSG WrapAtomic_FOUND)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBacktrace.cmake

@@ -0,0 +1,20 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(TARGET WrapBacktrace::WrapBacktrace)
+    set(WrapBacktrace_FOUND ON)
+    return()
+endif()
+
+find_package(Backtrace)
+
+if(Backtrace_FOUND)
+    add_library(WrapBacktrace::WrapBacktrace INTERFACE IMPORTED)
+    target_link_libraries(WrapBacktrace::WrapBacktrace
+                          INTERFACE ${Backtrace_LIBRARY})
+    target_include_directories(WrapBacktrace::WrapBacktrace
+                               INTERFACE ${Backtrace_INCLUDE_DIR})
+    set(WrapBacktrace_FOUND ON)
+else()
+    set(WrapBacktrace_FOUND OFF)
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBrotli.cmake

@@ -0,0 +1,107 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(TARGET WrapBrotli::WrapBrotliDec)
+    set(WrapBrotli_FOUND ON)
+    return()
+endif()
+
+# From VCPKG
+find_package(unofficial-brotli CONFIG QUIET)
+if (unofficial-brotli_FOUND)
+    add_library(WrapBrotli::WrapBrotliDec INTERFACE IMPORTED)
+    target_link_libraries(WrapBrotli::WrapBrotliDec INTERFACE unofficial::brotli::brotlidec)
+
+    add_library(WrapBrotli::WrapBrotliEnc INTERFACE IMPORTED)
+    target_link_libraries(WrapBrotli::WrapBrotliEnc INTERFACE unofficial::brotli::brotlienc)
+
+    add_library(WrapBrotli::WrapBrotliCommon INTERFACE IMPORTED)
+    target_link_libraries(WrapBrotli::WrapBrotliCommon INTERFACE unofficial::brotli::brotlicommon)
+
+    set(WrapBrotli_FOUND ON)
+else()
+    get_cmake_property(__packages_not_found PACKAGES_NOT_FOUND)
+    if(__packages_not_found)
+        list(REMOVE_ITEM __packages_not_found unofficial-brotli)
+        set_property(GLOBAL PROPERTY PACKAGES_NOT_FOUND "${__packages_not_found}")
+    endif()
+    unset(__packages_not_found)
+
+    find_package(PkgConfig QUIET)
+    if (PKG_CONFIG_FOUND)
+        pkg_check_modules(libbrotlidec QUIET IMPORTED_TARGET "libbrotlidec")
+        if (libbrotlidec_FOUND)
+            add_library(WrapBrotli::WrapBrotliDec INTERFACE IMPORTED)
+            target_link_libraries(WrapBrotli::WrapBrotliDec INTERFACE PkgConfig::libbrotlidec)
+            set(WrapBrotli_FOUND ON)
+        endif()
+
+        pkg_check_modules(libbrotlienc QUIET IMPORTED_TARGET "libbrotlienc")
+        if (libbrotlienc_FOUND)
+            add_library(WrapBrotli::WrapBrotliEnc INTERFACE IMPORTED)
+            target_link_libraries(WrapBrotli::WrapBrotliEnc INTERFACE PkgConfig::libbrotlienc)
+            set(WrapBrotli_FOUND ON)
+        endif()
+
+        pkg_check_modules(libbrotlicommon QUIET IMPORTED_TARGET "libbrotlicommon")
+        if (libbrotlicommon_FOUND)
+            add_library(WrapBrotli::WrapBrotliCommon INTERFACE IMPORTED)
+            target_link_libraries(WrapBrotli::WrapBrotliCommon INTERFACE PkgConfig::libbrotlicommon)
+            set(WrapBrotli_FOUND ON)
+        endif()
+    else()
+        find_path(BROTLI_INCLUDE_DIR NAMES "brotli/decode.h")
+
+        foreach(lib_name BrotliDec BrotliEnc BrotliCommon)
+            string(TOLOWER ${lib_name} lower_lib_name)
+
+            find_library(${lib_name}_LIBRARY_RELEASE
+                         NAMES ${lower_lib_name} ${lower_lib_name}-static)
+
+            find_library(${lib_name}_LIBRARY_DEBUG
+                         NAMES ${lower_lib_name}d ${lower_lib_name}-staticd
+                         ${lower_lib_name} ${lower_lib_name}-static)
+
+            include(SelectLibraryConfigurations)
+            select_library_configurations(${lib_name})
+
+            if (BROTLI_INCLUDE_DIR AND ${lib_name}_LIBRARY)
+                set(${lib_name}_FOUND TRUE)
+            endif()
+
+            if (${lib_name}_FOUND AND NOT TARGET WrapBrotli::Wrap${lib_name})
+                add_library(WrapBrotli::Wrap${lib_name} UNKNOWN IMPORTED)
+                set_target_properties(WrapBrotli::Wrap${lib_name} PROPERTIES
+                                      INTERFACE_INCLUDE_DIRECTORIES "${BROTLI_INCLUDE_DIR}"
+                                      IMPORTED_LOCATION "${${lib_name}_LIBRARY}")
+
+                if(${lib_name}_LIBRARY_RELEASE)
+                    foreach(config_name RELEASE RELWITHDEBINFO MINSIZEREL)
+                        set_property(TARGET WrapBrotli::Wrap${lib_name} APPEND PROPERTY
+                                     IMPORTED_CONFIGURATIONS ${config_name})
+                        set_target_properties(WrapBrotli::Wrap${lib_name} PROPERTIES
+                                              IMPORTED_LOCATION_${config_name} "${${lib_name}_LIBRARY_RELEASE}")
+                    endforeach()
+                endif()
+
+                if(${lib_name}_LIBRARY_DEBUG)
+                    set_property(TARGET WrapBrotli::Wrap${lib_name} APPEND PROPERTY
+                                 IMPORTED_CONFIGURATIONS DEBUG)
+                    set_target_properties(WrapBrotli::Wrap${lib_name} PROPERTIES
+                                          IMPORTED_LOCATION_DEBUG "${${lib_name}_LIBRARY_DEBUG}")
+                endif()
+            endif()
+        endforeach()
+
+        include(FindPackageHandleStandardArgs)
+        find_package_handle_standard_args(WrapBrotli REQUIRED_VARS
+                                          BrotliDec_FOUND BrotliEnc_FOUND BrotliCommon_FOUND)
+
+        if (WrapBrotli_FOUND)
+            set_property(TARGET WrapBrotli::WrapBrotliDec APPEND PROPERTY
+                         INTERFACE_LINK_LIBRARIES WrapBrotli::WrapBrotliCommon)
+            set_property(TARGET WrapBrotli::WrapBrotliEnc APPEND PROPERTY
+                         INTERFACE_LINK_LIBRARIES WrapBrotli::WrapBrotliCommon)
+        endif()
+    endif()
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledFreetypeConfigExtra.cmake

@@ -0,0 +1,4 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+set(QT_USE_BUNDLED_BundledFreetype ON CACHE INTERNAL "")

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledHarfbuzzConfigExtra.cmake

@@ -0,0 +1,4 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+set(QT_USE_BUNDLED_BundledHarfbuzz ON CACHE INTERNAL "")

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledLibjpegConfigExtra.cmake

@@ -0,0 +1,4 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+set(QT_USE_BUNDLED_BundledLibjpeg ON CACHE INTERNAL "")

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledLibpngConfigExtra.cmake

@@ -0,0 +1,4 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+set(QT_USE_BUNDLED_BundledLibpng ON CACHE INTERNAL "")

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledPcre2ConfigExtra.cmake

@@ -0,0 +1,4 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+set(QT_USE_BUNDLED_BundledPcre2 ON CACHE INTERNAL "")

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledZLIBConfigExtra.cmake

@@ -0,0 +1,4 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+set(QT_USE_BUNDLED_BundledZLIB ON CACHE INTERNAL "")

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapDBus1.cmake

@@ -0,0 +1,50 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# DBus1 is buggy and breaks PKG_CONFIG environment.
+# Work around that:-/
+# See https://gitlab.freedesktop.org/dbus/dbus/issues/267 for more information
+
+# When doing top-level static Qt builds, we need to protect against double creation of the dbus
+# target.
+if(DBus1_FOUND OR WrapDBus1_FOUND OR TARGET dbus-1)
+    set(WrapDBus1_FOUND 1)
+    return()
+endif()
+
+if(DEFINED ENV{PKG_CONFIG_DIR})
+    set(__qt_dbus_pcd "$ENV{PKG_CONFIG_DIR}")
+endif()
+if(DEFINED ENV{PKG_CONFIG_PATH})
+    set(__qt_dbus_pcp "$ENV{PKG_CONFIG_PATH}")
+endif()
+if(DEFINED ENV{PKG_CONFIG_LIBDIR})
+    set(__qt_dbus_pcl "$ENV{PKG_CONFIG_LIBDIR}")
+endif()
+
+find_package(DBus1 ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET)
+
+if(DEFINED __qt_dbus_pcd)
+    set(ENV{PKG_CONFIG_DIR} "${__qt_dbus_pcd}")
+else()
+    unset(ENV{PKG_CONFIG_DIR})
+endif()
+if(DEFINED __qt_dbus_pcp)
+    set(ENV{PKG_CONFIG_PATH} "${__qt_dbus_pcp}")
+else()
+    unset(ENV{PKG_CONFIG_PATH})
+endif()
+if(DEFINED __qt_dbus_pcl)
+    set(ENV{PKG_CONFIG_LIBDIR} "${__qt_dbus_pcl}")
+else()
+    unset(ENV{PKG_CONFIG_LIBDIR})
+endif()
+
+if(DBus1_FOUND)
+    set(WrapDBus1_FOUND 1)
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapDBus1 REQUIRED_VARS
+                                            DBus1_LIBRARY DBus1_INCLUDE_DIR WrapDBus1_FOUND
+                                            VERSION_VAR DBus1_VERSION)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapFreetype.cmake

@@ -0,0 +1,14 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+include(QtFindWrapHelper NO_POLICY_SCOPE)
+
+qt_find_package_system_or_bundled(wrap_freetype
+    FRIENDLY_PACKAGE_NAME "Freetype"
+    WRAP_PACKAGE_TARGET "WrapFreetype::WrapFreetype"
+    WRAP_PACKAGE_FOUND_VAR_NAME "WrapFreetype_FOUND"
+    BUNDLED_PACKAGE_NAME "BundledFreetype"
+    BUNDLED_PACKAGE_TARGET "BundledFreetype"
+    SYSTEM_PACKAGE_NAME "WrapSystemFreetype"
+    SYSTEM_PACKAGE_TARGET "WrapSystemFreetype::WrapSystemFreetype"
+)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapHarfbuzz.cmake

@@ -0,0 +1,14 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+include(QtFindWrapHelper NO_POLICY_SCOPE)
+
+qt_find_package_system_or_bundled(wrap_harfbuzz
+    FRIENDLY_PACKAGE_NAME "Harfbuzz"
+    WRAP_PACKAGE_TARGET "WrapHarfbuzz::WrapHarfbuzz"
+    WRAP_PACKAGE_FOUND_VAR_NAME "WrapHarfbuzz_FOUND"
+    BUNDLED_PACKAGE_NAME "BundledHarfbuzz"
+    BUNDLED_PACKAGE_TARGET "BundledHarfbuzz"
+    SYSTEM_PACKAGE_NAME "WrapSystemHarfbuzz"
+    SYSTEM_PACKAGE_TARGET "WrapSystemHarfbuzz::WrapSystemHarfbuzz"
+)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapJasper.cmake

@@ -0,0 +1,21 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapJasper::WrapJasper)
+    set(WrapJasper_FOUND TRUE)
+    return()
+endif()
+
+set(WrapJasper_FOUND OFF)
+find_package(Jasper)
+
+if(Jasper_FOUND)
+    set(WrapJasper_FOUND ON)
+
+    # Upstream package does not provide targets, only variables. So define a target.
+    add_library(WrapJasper::WrapJasper INTERFACE IMPORTED)
+    target_link_libraries(WrapJasper::WrapJasper INTERFACE ${JASPER_LIBRARIES})
+    target_include_directories(WrapJasper::WrapJasper INTERFACE ${JASPER_INCLUDE_DIR})
+endif()

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapJpeg.cmake

@@ -0,0 +1,14 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+include(QtFindWrapHelper NO_POLICY_SCOPE)
+
+qt_find_package_system_or_bundled(wrap_jpeg
+    FRIENDLY_PACKAGE_NAME "Jpeg"
+    WRAP_PACKAGE_TARGET "WrapJpeg::WrapJpeg"
+    WRAP_PACKAGE_FOUND_VAR_NAME "WrapJpeg_FOUND"
+    BUNDLED_PACKAGE_NAME "BundledLibjpeg"
+    BUNDLED_PACKAGE_TARGET "BundledLibjpeg"
+    SYSTEM_PACKAGE_NAME "WrapSystemJpeg"
+    SYSTEM_PACKAGE_TARGET "WrapSystemJpeg::WrapSystemJpeg"
+)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapLibClang.cmake

@@ -0,0 +1,95 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(TARGET WrapLibClang::WrapLibClang)
+    set(WrapLibClang_FOUND TRUE)
+    return()
+endif()
+
+if(DEFINED ENV{LLVM_INSTALL_DIR})
+    set(__qt_wrap_clang_backup_prefix "${CMAKE_PREFIX_PATH}")
+    list(PREPEND CMAKE_PREFIX_PATH "$ENV{LLVM_INSTALL_DIR}")
+elseif(DEFINED CACHE{LLVM_INSTALL_DIR})
+    set(__qt_wrap_clang_backup_prefix "${CMAKE_PREFIX_PATH}")
+    list(PREPEND CMAKE_PREFIX_PATH "${LLVM_INSTALL_DIR}")
+endif()
+
+find_package(Clang CONFIG)
+# LLVM versions >= 16 come with Findzstd.cmake that creates a target for libzstd.
+# Disable its global promotion to prevent interference with FindWrapZSTD.cmake.
+if(TARGET zstd::libzstd)
+    qt_internal_disable_find_package_global_promotion(zstd::libzstd)
+endif()
+if(TARGET zstd::libzstd_shared)
+    qt_internal_disable_find_package_global_promotion(zstd::libzstd_shared)
+endif()
+if(TARGET zstd::libzstd_static)
+    qt_internal_disable_find_package_global_promotion(zstd::libzstd_static)
+endif()
+
+if(__qt_wrap_clang_backup_prefix)
+    set(CMAKE_PREFIX_PATH "${__qt_wrap_clang_backup_prefix}")
+    unset(__qt_wrap_clang_backup_prefix)
+endif()
+
+set(WrapLibClang_FOUND FALSE)
+set(__wrap_lib_clang_requested_version_found FALSE)
+
+# Need to explicitly handle the version check, because the Clang package doesn't.
+if(WrapLibClang_FIND_VERSION AND LLVM_PACKAGE_VERSION
+        AND LLVM_PACKAGE_VERSION VERSION_GREATER_EQUAL "${WrapLibClang_FIND_VERSION}")
+    set(__wrap_lib_clang_requested_version_found TRUE)
+endif()
+
+if(TARGET libclang AND ((TARGET clang-cpp AND TARGET LLVM) OR TARGET clangHandleCXX) AND __wrap_lib_clang_requested_version_found)
+    set(WrapLibClang_FOUND TRUE)
+
+    get_target_property(type libclang TYPE)
+    if (MSVC AND type STREQUAL "STATIC_LIBRARY")
+        get_property(__wrap_lib_clang_multi_config
+            GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+        if(__wrap_lib_clang_multi_config)
+            set(__wrap_lib_clang_configs ${CMAKE_CONFIGURATION_TYPES})
+        else()
+            set(__wrap_lib_clang_configs ${CMAKE_BUILD_TYPE})
+        endif()
+        set(__wrap_lib_clang_non_release_configs ${configs})
+        list(REMOVE_ITEM __wrap_lib_clang_non_release_configs
+            Release MinSizeRel RelWithDebInfo)
+        if(__wrap_lib_clang_non_release_configs STREQUAL __wrap_lib_clang_configs)
+            message(STATUS "Static linkage against libclang with MSVC was requested, but the build is not a release build, therefore libclang cannot be used.")
+            set(WrapLibClang_FOUND FALSE)
+        endif()
+    endif()
+
+    if(WrapLibClang_FOUND)
+        add_library(WrapLibClang::WrapLibClang IMPORTED INTERFACE)
+
+        target_include_directories(WrapLibClang::WrapLibClang INTERFACE ${CLANG_INCLUDE_DIRS})
+        if (NOT TARGET Threads::Threads)
+            find_package(Threads)
+        endif()
+        qt_internal_disable_find_package_global_promotion(Threads::Threads)
+        # lupdate must also link to LLVM when using clang-cpp
+        set(__qt_clang_genex_condition "$<AND:$<TARGET_EXISTS:clang-cpp>,$<TARGET_EXISTS:LLVM>>")
+        set(__qt_clang_genex "$<IF:${__qt_clang_genex_condition},clang-cpp;LLVM,clangHandleCXX>")
+        target_link_libraries(WrapLibClang::WrapLibClang
+            INTERFACE libclang
+            "${__qt_clang_genex}"
+            Threads::Threads
+            )
+
+        foreach(version MAJOR MINOR PATCH)
+            set(QT_LIB_CLANG_VERSION_${version} ${LLVM_VERSION_${version}} CACHE STRING "" FORCE)
+        endforeach()
+        set(QT_LIB_CLANG_VERSION ${LLVM_PACKAGE_VERSION} CACHE STRING "" FORCE)
+        set(QT_LIB_CLANG_LIBDIR "${LLVM_LIBRARY_DIRS}" CACHE STRING "" FORCE)
+        set(QT_LIBCLANG_RESOURCE_DIR
+            "\"${QT_LIB_CLANG_LIBDIR}/clang/${QT_LIB_CLANG_VERSION}/include\"" CACHE STRING "" FORCE)
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapLibClang
+    REQUIRED_VARS WrapLibClang_FOUND
+    VERSION_VAR LLVM_PACKAGE_VERSION)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenGL.cmake

@@ -0,0 +1,66 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapOpenGL::WrapOpenGL)
+    set(WrapOpenGL_FOUND ON)
+    return()
+endif()
+
+set(WrapOpenGL_FOUND OFF)
+
+find_package(OpenGL ${WrapOpenGL_FIND_VERSION})
+
+if (OpenGL_FOUND)
+    set(WrapOpenGL_FOUND ON)
+
+    add_library(WrapOpenGL::WrapOpenGL INTERFACE IMPORTED)
+    if(APPLE)
+        # CMake 3.27 and older:
+        # On Darwin platforms FindOpenGL sets IMPORTED_LOCATION to the absolute path of the library
+        # within the framework. This ends up as an absolute path link flag, which we don't want,
+        # because that makes our .prl files un-relocatable.
+        # Extract the framework path instead, and use that in INTERFACE_LINK_LIBRARIES,
+        # which CMake ends up transforming into a relocatable -framework flag.
+        # See https://gitlab.kitware.com/cmake/cmake/-/issues/20871 for details.
+        #
+        # CMake 3.28 and above:
+        # IMPORTED_LOCATION is the absolute path the the OpenGL.framework folder.
+        get_target_property(__opengl_fw_lib_path OpenGL::GL IMPORTED_LOCATION)
+        if(__opengl_fw_lib_path AND NOT __opengl_fw_lib_path MATCHES "/([^/]+)\\.framework$")
+            get_filename_component(__opengl_fw_path "${__opengl_fw_lib_path}" DIRECTORY)
+        endif()
+
+        if(NOT __opengl_fw_path)
+            # Just a safety measure in case if no OpenGL::GL target exists.
+            set(__opengl_fw_path "-framework OpenGL")
+        endif()
+
+        find_library(WrapOpenGL_AGL NAMES AGL)
+        if(WrapOpenGL_AGL)
+            set(__opengl_agl_fw_path "${WrapOpenGL_AGL}")
+        endif()
+        if(NOT __opengl_agl_fw_path)
+            set(__opengl_agl_fw_path "-framework AGL")
+        endif()
+
+        target_link_libraries(WrapOpenGL::WrapOpenGL INTERFACE ${__opengl_fw_path})
+        target_link_libraries(WrapOpenGL::WrapOpenGL INTERFACE ${__opengl_agl_fw_path})
+    else()
+        target_link_libraries(WrapOpenGL::WrapOpenGL INTERFACE OpenGL::GL)
+    endif()
+elseif(UNIX AND NOT APPLE AND NOT CMAKE_SYSTEM_NAME STREQUAL "Integrity")
+    # Requesting only the OpenGL component ensures CMake does not mark the package as
+    # not found if neither GLX nor libGL are available. This allows finding OpenGL
+    # on an X11-less Linux system.
+    find_package(OpenGL ${WrapOpenGL_FIND_VERSION} COMPONENTS OpenGL)
+    if (OpenGL_FOUND)
+        set(WrapOpenGL_FOUND ON)
+        add_library(WrapOpenGL::WrapOpenGL INTERFACE IMPORTED)
+        target_link_libraries(WrapOpenGL::WrapOpenGL INTERFACE OpenGL::OpenGL)
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapOpenGL DEFAULT_MSG WrapOpenGL_FOUND)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenSSL.cmake

@@ -0,0 +1,42 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapOpenSSL::WrapOpenSSL)
+    set(WrapOpenSSL_FOUND ON)
+    return()
+endif()
+
+set(WrapOpenSSL_FOUND OFF)
+
+# Reuse logic from the headers find script.
+find_package(WrapOpenSSLHeaders ${WrapOpenSSL_FIND_VERSION})
+
+if(TARGET OpenSSL::SSL)
+    if(WIN32)
+        get_target_property(libType OpenSSL::Crypto TYPE)
+        if(libType STREQUAL "ALIAS")
+            get_target_property(writableLib OpenSSL::Crypto ALIASED_TARGET)
+        else()
+            set(writableLib OpenSSL::Crypto)
+        endif()
+        set_property(TARGET ${writableLib} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ws2_32 crypt32)
+        unset(libType)
+        unset(writableLib)
+    endif()
+
+    set(WrapOpenSSL_FOUND ON)
+
+    add_library(WrapOpenSSL::WrapOpenSSL INTERFACE IMPORTED)
+    target_link_libraries(WrapOpenSSL::WrapOpenSSL INTERFACE OpenSSL::SSL)
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapOpenSSL
+    REQUIRED_VARS
+        OPENSSL_CRYPTO_LIBRARY
+        OPENSSL_INCLUDE_DIR
+    VERSION_VAR
+        OPENSSL_VERSION
+)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenSSLHeaders.cmake

@@ -0,0 +1,45 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapOpenSSLHeaders::WrapOpenSSLHeaders)
+    set(WrapOpenSSLHeaders_FOUND ON)
+    return()
+endif()
+
+set(WrapOpenSSLHeaders_FOUND OFF)
+
+# When cross-compiling (to Android for example), we need to add the OPENSSL_ROOT_DIR as a root path,
+# otherwise the value would just be appended to the sysroot, which is wrong.
+if(OPENSSL_ROOT_DIR)
+    set(__find_wrap_openssl_headers_backup_root_dir "${CMAKE_FIND_ROOT_PATH}")
+    list(APPEND CMAKE_FIND_ROOT_PATH "${OPENSSL_ROOT_DIR}")
+endif()
+
+find_package(OpenSSL ${WrapOpenSSLHeaders_FIND_VERSION})
+
+if(OPENSSL_ROOT_DIR)
+    set(CMAKE_FIND_ROOT_PATH "${__find_wrap_openssl_headers_backup_root_dir}")
+endif()
+
+# We are interested only in include headers. The libraries might be missing, so we can't check the
+# _FOUND variable.
+if(OPENSSL_INCLUDE_DIR)
+    set(WrapOpenSSLHeaders_FOUND ON)
+
+    add_library(WrapOpenSSLHeaders::WrapOpenSSLHeaders INTERFACE IMPORTED)
+    target_include_directories(WrapOpenSSLHeaders::WrapOpenSSLHeaders INTERFACE
+        ${OPENSSL_INCLUDE_DIR})
+
+    set_target_properties(WrapOpenSSLHeaders::WrapOpenSSLHeaders PROPERTIES
+        _qt_is_nolink_target TRUE)
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapOpenSSLHeaders
+    REQUIRED_VARS
+        OPENSSL_INCLUDE_DIR
+    VERSION_VAR
+        OPENSSL_VERSION
+)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapPCRE2.cmake

@@ -0,0 +1,14 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+include(QtFindWrapHelper NO_POLICY_SCOPE)
+
+qt_find_package_system_or_bundled(wrap_pcre2
+    FRIENDLY_PACKAGE_NAME "PCRE2"
+    WRAP_PACKAGE_TARGET "WrapPCRE2::WrapPCRE2"
+    WRAP_PACKAGE_FOUND_VAR_NAME "WrapPCRE2_FOUND"
+    BUNDLED_PACKAGE_NAME "BundledPcre2"
+    BUNDLED_PACKAGE_TARGET "BundledPcre2"
+    SYSTEM_PACKAGE_NAME "WrapSystemPCRE2"
+    SYSTEM_PACKAGE_TARGET "WrapSystemPCRE2::WrapSystemPCRE2"
+)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapPNG.cmake

@@ -0,0 +1,14 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+include(QtFindWrapHelper NO_POLICY_SCOPE)
+
+qt_find_package_system_or_bundled(wrap_png
+    FRIENDLY_PACKAGE_NAME "PNG"
+    WRAP_PACKAGE_TARGET "WrapPNG::WrapPNG"
+    WRAP_PACKAGE_FOUND_VAR_NAME "WrapPNG_FOUND"
+    BUNDLED_PACKAGE_NAME "BundledLibpng"
+    BUNDLED_PACKAGE_TARGET "BundledLibpng"
+    SYSTEM_PACKAGE_NAME "WrapSystemPNG"
+    SYSTEM_PACKAGE_TARGET "WrapSystemPNG::WrapSystemPNG"
+)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapResolv.cmake

@@ -0,0 +1,53 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# Copyright (C) 2023 Intel Corpotation.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapResolv::WrapResolv)
+    set(WrapResolv_FOUND ON)
+    return()
+endif()
+
+set(WrapResolv_FOUND OFF)
+
+include(CheckCXXSourceCompiles)
+include(CMakePushCheckState)
+
+if(QNX)
+    find_library(LIBRESOLV socket)
+else()
+    find_library(LIBRESOLV resolv)
+endif()
+
+cmake_push_check_state()
+if(LIBRESOLV)
+    list(APPEND CMAKE_REQUIRED_LIBRARIES "${LIBRESOLV}")
+endif()
+
+check_cxx_source_compiles("
+#include <netinet/in.h>
+#include <resolv.h>
+
+int main(int, char **argv)
+{
+    res_state statep = 0;
+    int n = res_nmkquery(statep, 0, argv[1], 0, 0, NULL, 0, NULL, NULL, 0);
+    n = res_nsend(statep, NULL, 0, NULL, 0);
+    n = dn_expand(NULL, NULL, NULL, NULL, 0);
+    return n;
+}
+" HAVE_LIBRESOLV_FUNCTIONS)
+
+cmake_pop_check_state()
+
+if(HAVE_LIBRESOLV_FUNCTIONS)
+    set(WrapResolv_FOUND ON)
+    add_library(WrapResolv::WrapResolv INTERFACE IMPORTED)
+    if(LIBRESOLV)
+        target_link_libraries(WrapResolv::WrapResolv INTERFACE "${LIBRESOLV}")
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapResolv DEFAULT_MSG WrapResolv_FOUND)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapRt.cmake

@@ -0,0 +1,57 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapRt::WrapRt)
+    set(WrapRt_FOUND ON)
+    return()
+endif()
+
+set(WrapRt_FOUND OFF)
+
+include(CheckCXXSourceCompiles)
+include(CMakePushCheckState)
+
+find_library(LIBRT rt)
+
+cmake_push_check_state()
+if(LIBRT)
+    list(APPEND CMAKE_REQUIRED_LIBRARIES "${LIBRT}")
+endif()
+
+check_cxx_source_compiles("
+#include <time.h>
+#include <unistd.h>
+
+int main(int, char **) {
+    struct timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
+    return 0;
+}
+" HAVE_GETTIME)
+
+check_cxx_source_compiles("
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+
+int main(int, char **) {
+    shm_open(\"test\", O_RDWR | O_CREAT | O_EXCL, 0666);
+    shm_unlink(\"test\");
+    return 0;
+}
+" HAVE_SHM_OPEN_SHM_UNLINK)
+
+cmake_pop_check_state()
+
+if(HAVE_GETTIME OR HAVE_SHM_OPEN_SHM_UNLINK)
+    set(WrapRt_FOUND ON)
+    add_library(WrapRt::WrapRt INTERFACE IMPORTED)
+    if (LIBRT)
+        target_link_libraries(WrapRt::WrapRt INTERFACE "${LIBRT}")
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapRt DEFAULT_MSG WrapRt_FOUND)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemDoubleConversion.cmake

@@ -0,0 +1,85 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapSystemDoubleConversion::WrapSystemDoubleConversion)
+    set(WrapSystemDoubleConversion_FOUND ON)
+    return()
+endif()
+
+set(WrapSystemDoubleConversion_REQUIRED_VARS "__double_conversion_found")
+
+# Find either Config package or Find module.
+# Upstream can be built either with CMake and then provides a Config file, or with Scons in which
+# case there's no Config file.
+# A Find module might be provided by a 3rd party, for example Conan might generate a Find module.
+find_package(double-conversion ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET)
+set(__double_conversion_target_name "double-conversion::double-conversion")
+if(double-conversion_FOUND AND TARGET "${__double_conversion_target_name}")
+    set(__double_conversion_found TRUE)
+    # This ensures the Config file is shown in the fphsa message.
+    if(double-conversion_CONFIG)
+        list(PREPEND WrapSystemDoubleConversion_REQUIRED_VARS
+            double-conversion_CONFIG)
+    endif()
+endif()
+
+if(NOT __double_conversion_found)
+    list(PREPEND WrapSystemDoubleConversion_REQUIRED_VARS
+        DOUBLE_CONVERSION_LIBRARY DOUBLE_CONVERSION_INCLUDE_DIR)
+
+    find_path(DOUBLE_CONVERSION_INCLUDE_DIR
+        NAMES
+            double-conversion/double-conversion.h
+    )
+
+    find_library(DOUBLE_CONVERSION_LIBRARY_RELEASE NAMES double-conversion)
+
+    # We assume a possible debug build of this library to be named with a d suffix.
+    # Adjust accordingly if a different naming scheme is established.
+    find_library(DOUBLE_CONVERSION_LIBRARY_DEBUG NAMES double-conversiond)
+
+    include(SelectLibraryConfigurations)
+    select_library_configurations(DOUBLE_CONVERSION)
+    mark_as_advanced(DOUBLE_CONVERSION_INCLUDE_DIR DOUBLE_CONVERSION_LIBRARY)
+    set(DOUBLE_CONVERSION_INCLUDE_DIRS "${DOUBLE_CONVERSION_INCLUDE_DIR}")
+
+    if(DOUBLE_CONVERSION_LIBRARIES AND DOUBLE_CONVERSION_INCLUDE_DIRS)
+        set(__double_conversion_found TRUE)
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+
+set(__double_conversion_fphsa_args "")
+if(double-conversion_VERSION)
+    set(WrapSystemDoubleConversion_VERSION "${double-conversion_VERSION}")
+    list(APPEND __double_conversion_fphsa_args VERSION_VAR WrapSystemDoubleConversion_VERSION)
+endif()
+
+find_package_handle_standard_args(WrapSystemDoubleConversion
+    REQUIRED_VARS ${WrapSystemDoubleConversion_REQUIRED_VARS}
+    ${__double_conversion_fphsa_args})
+
+if(WrapSystemDoubleConversion_FOUND)
+    add_library(WrapSystemDoubleConversion::WrapSystemDoubleConversion INTERFACE IMPORTED)
+    if(TARGET "${__double_conversion_target_name}")
+        target_link_libraries(WrapSystemDoubleConversion::WrapSystemDoubleConversion
+                              INTERFACE "${__double_conversion_target_name}")
+    else()
+        target_link_libraries(WrapSystemDoubleConversion::WrapSystemDoubleConversion
+            INTERFACE ${DOUBLE_CONVERSION_LIBRARIES})
+        target_include_directories(WrapSystemDoubleConversion::WrapSystemDoubleConversion
+            INTERFACE ${DOUBLE_CONVERSION_INCLUDE_DIRS})
+    endif()
+endif()
+unset(__double_conversion_target_name)
+unset(__double_conversion_found)
+unset(__double_conversion_fphsa_args)
+
+include(FeatureSummary)
+set_package_properties(WrapSystemDoubleConversion PROPERTIES
+  URL "https://github.com/google/double-conversion"
+  DESCRIPTION "double-conversion library")
+

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemFreetype.cmake

@@ -0,0 +1,53 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapSystemFreetype::WrapSystemFreetype)
+    set(WrapSystemFreetype_FOUND TRUE)
+    return()
+endif()
+set(WrapSystemFreetype_REQUIRED_VARS __freetype_found)
+
+# Hunter has the package named freetype, but exports the Freetype::Freetype target as upstream
+# First try the CONFIG package, and afterwards the MODULE if not found
+find_package(Freetype ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION}
+             CONFIG NAMES Freetype freetype QUIET)
+if(NOT Freetype_FOUND)
+    find_package(Freetype ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET MODULE)
+endif()
+
+if(Freetype_FOUND)
+    # vcpkg defines a lower case target name, while upstream Find module defines a prefixed
+    # upper case name.
+    set(__freetype_potential_target_names Freetype::Freetype freetype)
+    foreach(__freetype_potential_target_name ${__freetype_potential_target_names})
+        if(TARGET "${__freetype_potential_target_name}")
+            set(__freetype_target_name "${__freetype_potential_target_name}")
+            set(__freetype_found TRUE)
+            break()
+        endif()
+    endforeach()
+endif()
+
+if(FREETYPE_LIBRARIES)
+    list(PREPEND WrapSystemFreetype_REQUIRED_VARS FREETYPE_LIBRARIES)
+endif()
+if(Freetype_VERSION)
+    set(WrapSystemFreetype_VERSION "${Freetype_VERSION}")
+elseif(FREETYPE_VERSION_STRING)
+    set(WrapSystemFreetype_VERSION "${FREETYPE_VERSION_STRING}")
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapSystemFreetype
+                                  REQUIRED_VARS ${WrapSystemFreetype_REQUIRED_VARS}
+                                  VERSION_VAR WrapSystemFreetype_VERSION)
+
+if(WrapSystemFreetype_FOUND)
+    add_library(WrapSystemFreetype::WrapSystemFreetype INTERFACE IMPORTED)
+    target_link_libraries(WrapSystemFreetype::WrapSystemFreetype
+                          INTERFACE "${__freetype_target_name}")
+endif()
+unset(__freetype_target_name)
+unset(__freetype_found)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemHarfbuzz.cmake

@@ -0,0 +1,90 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapSystemHarfbuzz::WrapSystemHarfbuzz)
+    set(WrapSystemHarfbuzz_FOUND TRUE)
+    return()
+endif()
+set(WrapSystemHarfbuzz_REQUIRED_VARS __harfbuzz_found)
+
+find_package(harfbuzz ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET)
+
+# Gentoo has some buggy version of a harfbuzz Config file. Check if include paths are valid.
+set(__harfbuzz_target_name "harfbuzz::harfbuzz")
+if(harfbuzz_FOUND AND TARGET "${__harfbuzz_target_name}")
+    get_property(__harfbuzz_include_paths TARGET "${__harfbuzz_target_name}"
+                                          PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
+    foreach(__harfbuzz_include_dir ${__harfbuzz_include_paths})
+        if(NOT EXISTS "${__harfbuzz_include_dir}")
+            # Must be the broken Gentoo harfbuzzConfig.cmake file. Try to use pkg-config instead.
+            set(__harfbuzz_broken_config_file TRUE)
+            break()
+        endif()
+    endforeach()
+
+    set(__harfbuzz_found TRUE)
+    if(harfbuzz_VERSION)
+        set(WrapSystemHarfbuzz_VERSION "${harfbuzz_VERSION}")
+    endif()
+else()
+    get_cmake_property(__packages_not_found PACKAGES_NOT_FOUND)
+    if(__packages_not_found)
+        list(REMOVE_ITEM __packages_not_found harfbuzz)
+        set_property(GLOBAL PROPERTY PACKAGES_NOT_FOUND "${__packages_not_found}")
+    endif()
+    unset(__packages_not_found)
+endif()
+
+if(__harfbuzz_broken_config_file OR NOT __harfbuzz_found)
+    find_package(PkgConfig QUIET)
+    pkg_check_modules(PC_HARFBUZZ IMPORTED_TARGET "harfbuzz")
+    if(PC_HARFBUZZ_FOUND)
+        set(__harfbuzz_target_name "PkgConfig::PC_HARFBUZZ")
+        set(__harfbuzz_find_include_dirs_hints
+            HINTS ${PC_HARFBUZZ_INCLUDEDIR})
+        set(__harfbuzz_find_library_hints
+            HINTS ${PC_HARFBUZZ_LIBDIR})
+        if(PC_HARFBUZZ_VERSION)
+            set(WrapSystemHarfbuzz_VERSION "${PC_HARFBUZZ_VERSION}")
+        endif()
+    else()
+        set(__harfbuzz_target_name "Harfbuzz::Harfbuzz")
+    endif()
+
+    find_path(HARFBUZZ_INCLUDE_DIRS
+        NAMES harfbuzz/hb.h
+        ${__harfbuzz_find_include_dirs_hints})
+    find_library(HARFBUZZ_LIBRARIES
+        NAMES harfbuzz
+        ${__harfbuzz_find_library_hints})
+
+    if(HARFBUZZ_INCLUDE_DIRS AND HARFBUZZ_LIBRARIES)
+        set(__harfbuzz_found TRUE)
+        if(NOT PC_HARFBUZZ_FOUND)
+            add_library(${__harfbuzz_target_name} UNKNOWN IMPORTED)
+            list(TRANSFORM HARFBUZZ_INCLUDE_DIRS APPEND "/harfbuzz")
+            set_target_properties(${__harfbuzz_target_name} PROPERTIES
+                IMPORTED_LOCATION "${HARFBUZZ_LIBRARIES}"
+                INTERFACE_INCLUDE_DIRECTORIES "${HARFBUZZ_INCLUDE_DIRS}"
+            )
+        endif()
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapSystemHarfbuzz
+                                  REQUIRED_VARS ${WrapSystemHarfbuzz_REQUIRED_VARS}
+                                  VERSION_VAR WrapSystemHarfbuzz_VERSION)
+if(WrapSystemHarfbuzz_FOUND)
+    add_library(WrapSystemHarfbuzz::WrapSystemHarfbuzz INTERFACE IMPORTED)
+    target_link_libraries(WrapSystemHarfbuzz::WrapSystemHarfbuzz
+                          INTERFACE "${__harfbuzz_target_name}")
+endif()
+unset(__harfbuzz_target_name)
+unset(__harfbuzz_find_include_dirs_hints)
+unset(__harfbuzz_find_library_hints)
+unset(__harfbuzz_found)
+unset(__harfbuzz_include_dir)
+unset(__harfbuzz_broken_config_file)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemJpeg.cmake

@@ -0,0 +1,35 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(TARGET WrapSystemJpeg::WrapSystemJpeg)
+    set(WrapSystemJpeg_FOUND TRUE)
+    return()
+endif()
+set(WrapSystemJpeg_REQUIRED_VARS __jpeg_found)
+
+find_package(JPEG ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET)
+
+set(__jpeg_target_name "JPEG::JPEG")
+if(JPEG_FOUND AND TARGET "${__jpeg_target_name}")
+    set(__jpeg_found TRUE)
+endif()
+
+if(JPEG_LIBRARIES)
+    list(PREPEND WrapSystemJpeg_REQUIRED_VARS JPEG_LIBRARIES)
+endif()
+if(JPEG_VERSION)
+    set(WrapSystemJpeg_VERSION "${JPEG_VERSION}")
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapSystemJpeg
+                                  REQUIRED_VARS ${WrapSystemJpeg_REQUIRED_VARS}
+                                  VERSION_VAR WrapSystemJpeg_VERSION)
+
+if(WrapSystemJpeg_FOUND)
+    add_library(WrapSystemJpeg::WrapSystemJpeg INTERFACE IMPORTED)
+    target_link_libraries(WrapSystemJpeg::WrapSystemJpeg
+                          INTERFACE "${__jpeg_target_name}")
+endif()
+unset(__jpeg_target_name)
+unset(__jpeg_found)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemMd4c.cmake

@@ -0,0 +1,43 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(TARGET WrapSystemMd4c::WrapSystemMd4c)
+    set(WrapSystemMd4c_FOUND TRUE)
+    return()
+endif()
+set(WrapSystemMd4c_REQUIRED_VARS __md4c_found)
+
+find_package(md4c ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET)
+
+set(__md4c_target_name "md4c::md4c")
+
+if(md4c_FOUND)
+    set(__md4c_found TRUE)
+
+    # md4c provides a md4c::md4c target but
+    # older versions create a md4c target without
+    # namespace. If we find the old variant create
+    # a namespaced target out of the md4c target.
+    if(TARGET md4c AND NOT TARGET ${__md4c_target_name})
+        add_library(${__md4c_target_name} INTERFACE IMPORTED)
+        target_link_libraries(${__md4c_target_name} INTERFACE md4c)
+    endif()
+
+    if(md4c_VERSION)
+        set(WrapSystemMd4c_VERSION "${md4c_VERSION}")
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapSystemMd4c
+                                  REQUIRED_VARS ${WrapSystemMd4c_REQUIRED_VARS}
+                                  VERSION_VAR WrapSystemMd4c_VERSION)
+
+if(WrapSystemMd4c_FOUND)
+    add_library(WrapSystemMd4c::WrapSystemMd4c INTERFACE IMPORTED)
+    target_link_libraries(WrapSystemMd4c::WrapSystemMd4c
+                          INTERFACE "${__md4c_target_name}")
+endif()
+
+unset(__md4c_found)
+unset(__md4c_target_name)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemPCRE2.cmake

@@ -0,0 +1,69 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(TARGET WrapSystemPCRE2::WrapSystemPCRE2)
+    set(WrapSystemPCRE2_FOUND TRUE)
+    return()
+endif()
+set(WrapSystemPCRE2_REQUIRED_VARS __pcre2_found)
+
+find_package(PCRE2 ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} COMPONENTS 16BIT QUIET)
+
+set(__pcre2_target_name "PCRE2::16BIT")
+if(PCRE2_FOUND AND TARGET "${__pcre2_target_name}")
+  # Hunter case.
+  set(__pcre2_found TRUE)
+  if(PCRE2_VERSION)
+      set(WrapSystemPCRE2_VERSION "${PCRE2_VERSION}")
+  endif()
+else()
+    get_cmake_property(__packages_not_found PACKAGES_NOT_FOUND)
+    if(__packages_not_found)
+        list(REMOVE_ITEM __packages_not_found PCRE2)
+        set_property(GLOBAL PROPERTY PACKAGES_NOT_FOUND "${__packages_not_found}")
+    endif()
+    unset(__packages_not_found)
+endif()
+
+if(NOT __pcre2_found)
+  list(PREPEND WrapSystemPCRE2_REQUIRED_VARS PCRE2_LIBRARIES PCRE2_INCLUDE_DIRS)
+
+  find_package(PkgConfig QUIET)
+  pkg_check_modules(PC_PCRE2 QUIET "libpcre2-16")
+
+  find_path(PCRE2_INCLUDE_DIRS
+            NAMES pcre2.h
+            HINTS ${PC_PCRE2_INCLUDEDIR})
+  find_library(PCRE2_LIBRARY_RELEASE
+              NAMES pcre2-16
+              HINTS ${PC_PCRE2_LIBDIR})
+  find_library(PCRE2_LIBRARY_DEBUG
+              NAMES pcre2-16d pcre2-16
+              HINTS ${PC_PCRE2_LIBDIR})
+  include(SelectLibraryConfigurations)
+  select_library_configurations(PCRE2)
+
+  if(PC_PCRE2_VERSION)
+      set(WrapSystemPCRE2_VERSION "${PC_PCRE2_VERSION}")
+  endif()
+
+  if (PCRE2_LIBRARIES AND PCRE2_INCLUDE_DIRS)
+      set(__pcre2_found TRUE)
+  endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapSystemPCRE2
+                                  REQUIRED_VARS ${WrapSystemPCRE2_REQUIRED_VARS}
+                                  VERSION_VAR WrapSystemPCRE2_VERSION)
+if(WrapSystemPCRE2_FOUND)
+    add_library(WrapSystemPCRE2::WrapSystemPCRE2 INTERFACE IMPORTED)
+    if(TARGET "${__pcre2_target_name}")
+        target_link_libraries(WrapSystemPCRE2::WrapSystemPCRE2 INTERFACE "${__pcre2_target_name}")
+    else()
+        target_link_libraries(WrapSystemPCRE2::WrapSystemPCRE2 INTERFACE ${PCRE2_LIBRARIES})
+        target_include_directories(WrapSystemPCRE2::WrapSystemPCRE2 INTERFACE ${PCRE2_INCLUDE_DIRS})
+    endif()
+endif()
+unset(__pcre2_target_name)
+unset(__pcre2_found)

qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemPNG.cmake

@@ -0,0 +1,42 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapSystemPNG::WrapSystemPNG)
+    set(WrapSystemPNG_FOUND TRUE)
+    return()
+endif()
+set(WrapSystemPNG_REQUIRED_VARS __png_found)
+
+find_package(PNG ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET)
+
+set(__png_target_name "PNG::PNG")
+if(PNG_FOUND AND TARGET "${__png_target_name}")
+    set(__png_found TRUE)
+    if(PNG_VERSION)
+        set(WrapSystemPNG_VERSION "${PNG_VERSION}")
+    endif()
+endif()
+
+if(PNG_LIBRARIES)
+    list(PREPEND WrapSystemPNG_REQUIRED_VARS PNG_LIBRARIES)
+endif()
+if(PNG_VERSION)
+    set(WrapSystemPNG_VERSION "${PNG_VERSION}")
+elseif(PNG_VERSION_STRING)
+    set(WrapSystemPNG_VERSION "${PNG_VERSION_STRING}")
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapSystemPNG
+                                  REQUIRED_VARS ${WrapSystemPNG_REQUIRED_VARS}
+                                  VERSION_VAR WrapSystemPNG_VERSION)
+
+if(WrapSystemPNG_FOUND)
+    add_library(WrapSystemPNG::WrapSystemPNG INTERFACE IMPORTED)
+    target_link_libraries(WrapSystemPNG::WrapSystemPNG
+                          INTERFACE "${__png_target_name}")
+endif()
+unset(__png_target_name)
+unset(__png_found)