Update for Vulkan-Docs 1.4.312

adjusted fnc name
simplified cpp module to not require function loading
2025-04-05 21:24:58 +00:00 · 2025-04-04 04:45:22 -07:00 · 2025-03-31 09:52:53 -06:00 · 2025-03-31 09:52:53 -06:00 · 2025-03-31 09:52:53 -06:00 · 2025-03-31 09:52:53 -06:00
34 changed files with 45759 additions and 5376 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -21,7 +21,7 @@ jobs:
    strategy:
      matrix:
        os: [ ubuntu-latest, macos-latest ]
-        cmake-version: [ '3.15', 'latest']
+        cmake-version: [ '3.22.1', 'latest']
    steps:
      - uses: actions/checkout@v4
      - uses: lukka/get-cmake@latest
@ -39,7 +39,7 @@ jobs:
    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
    strategy:
      matrix:
-        cmake-version: [ '3.15', 'latest']
+        cmake-version: [ '3.22.1', 'latest']
    steps:
      - uses: actions/checkout@v4
      - uses: lukka/get-cmake@latest
@ -74,6 +74,58 @@ jobs:
        - run: ctest --output-on-failure
          working-directory: build

+  cmake-unix-modules:
+    runs-on: ${{ matrix.os }}
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+    strategy:
+      matrix:
+        os: [ ubuntu-latest ]
+        cmake-version: [ 'latest' ]
+        compiler: [ clang++-18 ]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: ${{ matrix.cmake-version }}
+      - uses: ilammy/msvc-dev-cmd@v1
+      - run: |
+          cmake -S . -B build \
+          -D VULKAN_HEADERS_ENABLE_TESTS=ON \
+          -D VULKAN_HEADERS_ENABLE_INSTALL=ON \
+          -D VULKAN_HEADERS_ENABLE_MODULE=ON \
+          -D VULKAN_HEADERS_ENABLE_MODULE_STD=OFF \
+          -D CMAKE_CXX_COMPILER=${{ matrix.compiler }} \
+          -G Ninja
+      - run: cmake --build ./build
+      - run: cmake --install build/ --prefix build/install
+      - run: CXX=${{ matrix.compiler }} ctest --output-on-failure
+        working-directory: build
+
+  cmake-windows-modules:
+    runs-on: ${{ matrix.os }}
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+    strategy:
+      matrix:
+        os: [ windows-latest ]
+        cmake-version: [ 'latest' ]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: ${{ matrix.cmake-version }}
+      - uses: ilammy/msvc-dev-cmd@v1
+      - run: |
+          cmake -S . -B build `
+          -D VULKAN_HEADERS_ENABLE_TESTS=ON `
+          -D VULKAN_HEADERS_ENABLE_INSTALL=ON `
+          -D VULKAN_HEADERS_ENABLE_MODULE=ON `
+          -D VULKAN_HEADERS_ENABLE_MODULE_STD=OFF `
+          -G Ninja
+      - run: cmake --build ./build
+      - run: cmake --install build/ --prefix build/install
+      - run: ctest --output-on-failure
+        working-directory: build
+
  reuse:
    runs-on: ubuntu-latest
    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
--- a/BUILD.gn
+++ b/BUILD.gn
@ -13,7 +13,10 @@ config("vulkan_headers_config") {
    defines += [ "VK_USE_PLATFORM_WIN32_KHR" ]
  }
  if (defined(vulkan_use_x11) && vulkan_use_x11) {
-    defines += [ "VK_USE_PLATFORM_XCB_KHR" ]
+    defines += [
+      "VK_USE_PLATFORM_XCB_KHR",
+      "VK_USE_PLATFORM_XLIB_KHR",
+    ]
  }
  if (defined(vulkan_use_wayland) && vulkan_use_wayland) {
    defines += [ "VK_USE_PLATFORM_WAYLAND_KHR" ]
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -5,7 +5,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 # ~~~
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.22.1)

 # NOTE: Parsing the version like this is suboptimal but neccessary due to our release process:
 # https://github.com/KhronosGroup/Vulkan-Headers/pull/346
@ -38,48 +38,68 @@ vlk_get_header_version()

 project(VULKAN_HEADERS LANGUAGES C CXX VERSION ${VK_VERSION_STRING})

+# options for Vulkan-Headers and the Vulkan-Hpp C++20 module
+option(VULKAN_HEADERS_ENABLE_TESTS "Test Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
+option(VULKAN_HEADERS_ENABLE_INSTALL "Install Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
+option(VULKAN_HEADERS_ENABLE_MODULE "Enables building of the Vulkan C++20 module; requires minimum CMake version 3.28" OFF)
+option(VULKAN_HEADERS_ENABLE_MODULE_STD "Enables building of the Vulkan C++20 module with import std; requires minimum CMake version 3.30" OFF)
+
+# set up Vulkan-Headers
 add_library(Vulkan-Headers INTERFACE)
 add_library(Vulkan::Headers ALIAS Vulkan-Headers)
 target_include_directories(Vulkan-Headers INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)

-if ((CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND (MSVC_VERSION GREATER_EQUAL "1941")) OR
-    # clang-cl doesn't currently support modules
-    (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
-        AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "16.0"
-        AND (NOT CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES "MSVC")
-        AND (NOT CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS STREQUAL CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS-NOTFOUND)) OR
-    (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0"))
-    set(COMPILER_SUPPORTS_CXX_MODULES TRUE)
-endif()
-
-option(VULKAN_HEADERS_ENABLE_MODULE "Enables building of the Vulkan C++ module" OFF)
-
-if (VULKAN_HEADERS_ENABLE_MODULE AND (NOT COMPILER_SUPPORTS_CXX_MODULES OR CMAKE_VERSION VERSION_LESS "3.28"))
-    message(WARNING "Vulkan C++ module support is requested but was disabled due to lacking support on this platform")
-endif()
-
-if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.28" AND VULKAN_HEADERS_ENABLE_MODULE AND COMPILER_SUPPORTS_CXX_MODULES)
-    add_library(Vulkan-Module)
-    add_library(Vulkan::VulkanHppModule ALIAS Vulkan-Module)
-    target_sources(Vulkan-Module
-        PUBLIC
-            FILE_SET module
-                TYPE CXX_MODULES
-                BASE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/include"
-                FILES "${CMAKE_CURRENT_SOURCE_DIR}/include/vulkan/vulkan.cppm"
+if (VULKAN_HEADERS_ENABLE_MODULE)
+    # check for compiler support
+    if ((CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND (MSVC_VERSION GREATER_EQUAL "1941")) OR
+        # clang-cl doesn't currently support modules
+        (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
+            AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "16.0"
+            AND (NOT CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES "MSVC")
+            AND (NOT CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS STREQUAL CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS-NOTFOUND)) OR
+        (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0")
    )
-    target_compile_features(Vulkan-Module PUBLIC cxx_std_20)
-    target_link_libraries(Vulkan-Module PUBLIC Vulkan-Headers)
-endif ()
+        # check for CMake support
+        if(VULKAN_HEADERS_ENABLE_MODULE_STD AND CMAKE_VERSION VERSION_LESS "3.30")
+            message(FATAL_ERROR "Vulkan-Hpp: C++20 module with import std requires CMake 3.30 or later")
+        elseif (CMAKE_VERSION VERSION_LESS "3.28")
+            message(FATAL_ERROR "Vulkan-Hpp: C++20 module requires CMake 3.28 or later")
+        endif()
+        
+        # set up Vulkan-HppModule
+        add_library(Vulkan-HppModule)
+        add_library(Vulkan::HppModule ALIAS Vulkan-HppModule)
+        target_sources(Vulkan-HppModule
+            PUBLIC
+            FILE_SET module
+            TYPE CXX_MODULES
+            FILES "${CMAKE_CURRENT_SOURCE_DIR}/include/vulkan/vulkan.cppm")
+        if (VULKAN_HEADERS_ENABLE_MODULE_STD)
+            target_compile_features(Vulkan-HppModule
+                PRIVATE   cxx_std_23
+                INTERFACE cxx_std_20) # only C++20 is required to consume this module
+            set_target_properties(Vulkan-HppModule PROPERTIES CXX_MODULE_STD ON)
+        else()
+            target_compile_features(Vulkan-HppModule PUBLIC cxx_std_20)
+        endif()
+        target_link_libraries(Vulkan-HppModule PUBLIC Vulkan::Headers)

-if (CMAKE_VERSION VERSION_LESS "3.21")
-    # https://cmake.org/cmake/help/latest/variable/PROJECT_IS_TOP_LEVEL.html
-    string(COMPARE EQUAL ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR} PROJECT_IS_TOP_LEVEL)
+        # Clang 16's module support can be broken with extensions enabled
+        if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "16.0")
+            set_target_properties(Vulkan-HppModule PROPERTIES CXX_EXTENSIONS OFF)
+        endif()
+
+        # set up fallback targets to notify about name deprecation
+        add_library(Vulkan-Module INTERFACE)
+        add_library(Vulkan::Module ALIAS Vulkan-Module)
+        target_link_libraries(Vulkan-Module INTERFACE Vulkan::HppModule)
+        set_target_properties(Vulkan-Module PROPERTIES 
+            DEPRECATION "The Vulkan-Module and Vulkan::Module targets have been deprecated by the Vulkan-HppModule and Vulkan::HppModule targets respectively and will be removed at a future date.")
+    else()
+        message(FATAL_ERROR "Vulkan-Hpp: C++20 module support is requested but was disabled due to lacking compiler support on this platform")
+    endif()
 endif()

-option(VULKAN_HEADERS_ENABLE_TESTS "Test Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
-option(VULKAN_HEADERS_ENABLE_INSTALL "Install Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
-
 if (VULKAN_HEADERS_ENABLE_TESTS)
    enable_testing() # This is only effective in the top level CMakeLists.txt file.
    add_subdirectory(tests)
--- a/Makefile.release
+++ b/Makefile.release
@ -57,6 +57,7 @@ update-headers:

 # Top-level scripts / XML to install
 SCRIPTS = \
+    $(SPEC)/scripts/base_generator.py \
    $(SPEC)/scripts/cgenerator.py \
    $(SPEC)/scripts/generator.py \
    $(SPEC)/scripts/parse_dependency.py \
@ -64,6 +65,7 @@ SCRIPTS = \
    $(SPEC)/scripts/stripAPI.py \
    $(SPEC)/scripts/apiconventions.py \
    $(SPEC)/scripts/vkconventions.py \
+    $(SPEC)/scripts/vulkan_object.py \
    $(SPEC)/xml/vk.xml \
    $(SPEC)/xml/video.xml \
    $(REGISTRY)/specs/latest/validation/validusage.json
--- a/include/vulkan/vulkan.cppm
+++ b/include/vulkan/vulkan.cppm
@ -22,7 +22,9 @@ module;
 #include <vulkan/vulkan_hash.hpp>
 #include <vulkan/vulkan_raii.hpp>
 #include <vulkan/vulkan_shared.hpp>
-#include <vulkan/vulkan_to_string.hpp>
+#ifndef VULKAN_HPP_NO_TO_STRING
+#  include <vulkan/vulkan_to_string.hpp>
+#endif

 export module vulkan_hpp;

@ -751,6 +753,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagBitsNV;
  using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV;

+  //=== VK_QCOM_tile_shading ===
+  using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagBitsQCOM;
+  using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagsQCOM;
+
 #if defined( VK_USE_PLATFORM_METAL_EXT )
  //=== VK_EXT_metal_objects ===
  using VULKAN_HPP_NAMESPACE::ExportMetalObjectTypeFlagBitsEXT;
@ -835,6 +841,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagBitsNV;
  using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagsNV;

+  //=== VK_NV_ray_tracing_linear_swept_spheres ===
+  using VULKAN_HPP_NAMESPACE::RayTracingLssIndexingModeNV;
+  using VULKAN_HPP_NAMESPACE::RayTracingLssPrimitiveEndCapsModeNV;
+
  //=== VK_EXT_subpass_merge_feedback ===
  using VULKAN_HPP_NAMESPACE::SubpassMergeStatusEXT;

@ -867,6 +877,11 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_NV_ray_tracing_invocation_reorder ===
  using VULKAN_HPP_NAMESPACE::RayTracingInvocationReorderModeNV;

+  //=== VK_NV_cooperative_vector ===
+  using VULKAN_HPP_NAMESPACE::ComponentTypeKHR;
+  using VULKAN_HPP_NAMESPACE::ComponentTypeNV;
+  using VULKAN_HPP_NAMESPACE::CooperativeVectorMatrixLayoutNV;
+
  //=== VK_EXT_layer_settings ===
  using VULKAN_HPP_NAMESPACE::LayerSettingTypeEXT;

@ -875,8 +890,6 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV;

  //=== VK_KHR_cooperative_matrix ===
-  using VULKAN_HPP_NAMESPACE::ComponentTypeKHR;
-  using VULKAN_HPP_NAMESPACE::ComponentTypeNV;
  using VULKAN_HPP_NAMESPACE::ScopeKHR;
  using VULKAN_HPP_NAMESPACE::ScopeNV;

@ -911,6 +924,24 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_KHR_maintenance7 ===
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiKHR;

+  //=== VK_NV_cluster_acceleration_structure ===
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureAddressResolutionFlagBitsNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureAddressResolutionFlagsNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClusterFlagBitsNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClusterFlagsNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryFlagBitsNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryFlagsNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureIndexFormatFlagBitsNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureIndexFormatFlagsNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpModeNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpTypeNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTypeNV;
+
+  //=== VK_NV_partitioned_acceleration_structure ===
+  using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstanceFlagBitsNV;
+  using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstanceFlagsNV;
+  using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureOpTypeNV;
+
  //=== VK_EXT_device_generated_commands ===
  using VULKAN_HPP_NAMESPACE::IndirectCommandsInputModeFlagBitsEXT;
  using VULKAN_HPP_NAMESPACE::IndirectCommandsInputModeFlagsEXT;
@ -1528,6 +1559,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportExtensionName;
  using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportSpecVersion;

+  //=== VK_KHR_shader_bfloat16 ===
+  using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16ExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16SpecVersion;
+
  //=== VK_EXT_sample_locations ===
  using VULKAN_HPP_NAMESPACE::EXTSampleLocationsExtensionName;
  using VULKAN_HPP_NAMESPACE::EXTSampleLocationsSpecVersion;
@ -2061,6 +2096,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::NVCudaKernelLaunchSpecVersion;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_QCOM_tile_shading ===
+  using VULKAN_HPP_NAMESPACE::QCOMTileShadingExtensionName;
+  using VULKAN_HPP_NAMESPACE::QCOMTileShadingSpecVersion;
+
  //=== VK_NV_low_latency ===
  using VULKAN_HPP_NAMESPACE::NVLowLatencyExtensionName;
  using VULKAN_HPP_NAMESPACE::NVLowLatencySpecVersion;
@ -2371,6 +2410,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsComputeExtensionName;
  using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsComputeSpecVersion;

+  //=== VK_NV_ray_tracing_linear_swept_spheres ===
+  using VULKAN_HPP_NAMESPACE::NVRayTracingLinearSweptSpheresExtensionName;
+  using VULKAN_HPP_NAMESPACE::NVRayTracingLinearSweptSpheresSpecVersion;
+
  //=== VK_NV_linear_color_attachment ===
  using VULKAN_HPP_NAMESPACE::NVLinearColorAttachmentExtensionName;
  using VULKAN_HPP_NAMESPACE::NVLinearColorAttachmentSpecVersion;
@ -2475,6 +2518,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::NVRayTracingInvocationReorderExtensionName;
  using VULKAN_HPP_NAMESPACE::NVRayTracingInvocationReorderSpecVersion;

+  //=== VK_NV_cooperative_vector ===
+  using VULKAN_HPP_NAMESPACE::NVCooperativeVectorExtensionName;
+  using VULKAN_HPP_NAMESPACE::NVCooperativeVectorSpecVersion;
+
  //=== VK_NV_extended_sparse_address_space ===
  using VULKAN_HPP_NAMESPACE::NVExtendedSparseAddressSpaceExtensionName;
  using VULKAN_HPP_NAMESPACE::NVExtendedSparseAddressSpaceSpecVersion;
@ -2614,6 +2661,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName;
  using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion;

+  //=== VK_NV_external_compute_queue ===
+  using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueExtensionName;
+  using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueSpecVersion;
+
  //=== VK_KHR_shader_relaxed_extended_instruction ===
  using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionExtensionName;
  using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionSpecVersion;
@ -2638,6 +2689,15 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::NVRayTracingValidationExtensionName;
  using VULKAN_HPP_NAMESPACE::NVRayTracingValidationSpecVersion;

+  //=== VK_NV_cluster_acceleration_structure ===
+  using VULKAN_HPP_NAMESPACE::NVClusterAccelerationStructureExtensionName;
+  using VULKAN_HPP_NAMESPACE::NVClusterAccelerationStructureSpecVersion;
+
+  //=== VK_NV_partitioned_acceleration_structure ===
+  using VULKAN_HPP_NAMESPACE::NVPartitionedAccelerationStructureExtensionName;
+  using VULKAN_HPP_NAMESPACE::NVPartitionedAccelerationStructureSpecVersion;
+  using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructurePartitionIndexGlobalNV;
+
  //=== VK_EXT_device_generated_commands ===
  using VULKAN_HPP_NAMESPACE::EXTDeviceGeneratedCommandsExtensionName;
  using VULKAN_HPP_NAMESPACE::EXTDeviceGeneratedCommandsSpecVersion;
@ -2654,6 +2714,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::EXTDepthClampControlExtensionName;
  using VULKAN_HPP_NAMESPACE::EXTDepthClampControlSpecVersion;

+  //=== VK_KHR_video_maintenance2 ===
+  using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2ExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2SpecVersion;
+
  //=== VK_HUAWEI_hdr_vivid ===
  using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividExtensionName;
  using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividSpecVersion;
@ -2666,6 +2730,12 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapExtensionName;
  using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapSpecVersion;

+#if defined( VK_USE_PLATFORM_METAL_EXT )
+  //=== VK_EXT_external_memory_metal ===
+  using VULKAN_HPP_NAMESPACE::EXTExternalMemoryMetalExtensionName;
+  using VULKAN_HPP_NAMESPACE::EXTExternalMemoryMetalSpecVersion;
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
  //=== VK_KHR_depth_clamp_zero_one ===
  using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneExtensionName;
  using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneSpecVersion;
@ -2674,6 +2744,16 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessExtensionName;
  using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessSpecVersion;

+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+  //=== VK_NV_present_metering ===
+  using VULKAN_HPP_NAMESPACE::NVPresentMeteringExtensionName;
+  using VULKAN_HPP_NAMESPACE::NVPresentMeteringSpecVersion;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+  //=== VK_EXT_fragment_density_map_offset ===
+  using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetExtensionName;
+  using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetSpecVersion;
+
  //========================
  //=== CONSTEXPR VALUEs ===
  //========================
@ -3663,6 +3743,9 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD;
  using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV;

+  //=== VK_KHR_shader_bfloat16 ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR;
+
  //=== VK_EXT_sample_locations ===
  using VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT;
  using VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT;
@ -4061,6 +4144,14 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_QCOM_tile_shading ===
+  using VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM;
+  using VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM;
+  using VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM;
+  using VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM;
+
  //=== VK_NV_low_latency ===
  using VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV;

@ -4342,11 +4433,6 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM;
  using VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM;

-  //=== VK_QCOM_fragment_density_map_offset ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
-  using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
-
  //=== VK_NV_copy_memory_indirect ===
  using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV;
  using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV;
@ -4364,6 +4450,11 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
  using VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV;

+  //=== VK_NV_ray_tracing_linear_swept_spheres ===
+  using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV;
+  using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV;
+
  //=== VK_NV_linear_color_attachment ===
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV;

@ -4474,6 +4565,12 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV;

+  //=== VK_NV_cooperative_vector ===
+  using VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV;
+  using VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV;
+
  //=== VK_NV_extended_sparse_address_space ===
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
@ -4620,6 +4717,12 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_NV_raw_access_chains ===
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV;

+  //=== VK_NV_external_compute_queue ===
+  using VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV;
+  using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV;
+  using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV;
+
  //=== VK_KHR_shader_relaxed_extended_instruction ===
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;

@ -4642,6 +4745,36 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_NV_ray_tracing_validation ===
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV;

+  //=== VK_NV_cluster_acceleration_structure ===
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV;
+  using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV;
+  using VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV;
+  using VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV;
+
+  //=== VK_NV_partitioned_acceleration_structure ===
+  using VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV;
+  using VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV;
+  using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV;
+  using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV;
+  using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV;
+  using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV;
+  using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV;
+  using VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV;
+  using VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV;
+  using VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV;
+
  //=== VK_EXT_device_generated_commands ===
  using VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT;
  using VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT;
@ -4681,6 +4814,12 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT;
  using VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT;

+  //=== VK_KHR_video_maintenance2 ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR;
+  using VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR;
+  using VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR;
+  using VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR;
+
  //=== VK_HUAWEI_hdr_vivid ===
  using VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI;
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI;
@ -4693,6 +4832,13 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_ARM_pipeline_opacity_micromap ===
  using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM;

+#if defined( VK_USE_PLATFORM_METAL_EXT )
+  //=== VK_EXT_external_memory_metal ===
+  using VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT;
+  using VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT;
+  using VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT;
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
  //=== VK_KHR_depth_clamp_zero_one ===
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT;
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR;
@ -4700,6 +4846,21 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_EXT_vertex_attribute_robustness ===
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;

+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+  //=== VK_NV_present_metering ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV;
+  using VULKAN_HPP_NAMESPACE::SetPresentConfigNV;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+  //=== VK_EXT_fragment_density_map_offset ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+  using VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT;
+  using VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT;
+  using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
+
  //===============
  //=== HANDLEs ===
  //===============
@ -4805,6 +4966,9 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_KHR_pipeline_binary ===
  using VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;

+  //=== VK_NV_external_compute_queue ===
+  using VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV;
+
  //=== VK_EXT_device_generated_commands ===
  using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT;
  using VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT;
@ -4911,6 +5075,9 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_KHR_pipeline_binary ===
  using VULKAN_HPP_NAMESPACE::UniquePipelineBinaryKHR;

+  //=== VK_NV_external_compute_queue ===
+  using VULKAN_HPP_NAMESPACE::UniqueExternalComputeQueueNV;
+
  //=== VK_EXT_device_generated_commands ===
  using VULKAN_HPP_NAMESPACE::UniqueHandleTraits;
  using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutEXT;
@ -5022,6 +5189,9 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_KHR_pipeline_binary ===
  using VULKAN_HPP_NAMESPACE::SharedPipelineBinaryKHR;

+  //=== VK_NV_external_compute_queue ===
+  using VULKAN_HPP_NAMESPACE::SharedExternalComputeQueueNV;
+
  //=== VK_EXT_device_generated_commands ===
  using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
  using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutEXT;
@ -5217,6 +5387,9 @@ export namespace VULKAN_HPP_NAMESPACE
    using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR;
    using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHRs;

+    //=== VK_NV_external_compute_queue ===
+    using VULKAN_HPP_RAII_NAMESPACE::ExternalComputeQueueNV;
+
    //=== VK_EXT_device_generated_commands ===
    using VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutEXT;
    using VULKAN_HPP_RAII_NAMESPACE::IndirectExecutionSetEXT;
@ -5389,6 +5562,10 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>;

+  //=== VK_NV_external_compute_queue ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>;
+
  //=== VK_EXT_device_generated_commands ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT>;
@ -6651,6 +6828,10 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>;

+  //=== VK_KHR_shader_bfloat16 ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>;
+
  //=== VK_EXT_sample_locations ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>;
@ -7275,6 +7456,20 @@ export namespace std
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV>;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_QCOM_tile_shading ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM>;
+
  //=== VK_NV_low_latency ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV>;
@ -7711,14 +7906,6 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>;

-  //=== VK_QCOM_fragment_density_map_offset ===
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>;
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>;
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>;
-
  //=== VK_NV_copy_memory_indirect ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV>;
@ -7747,6 +7934,14 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV>;

+  //=== VK_NV_ray_tracing_linear_swept_spheres ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV>;
+
  //=== VK_NV_linear_color_attachment ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>;
@ -7927,6 +8122,20 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV>;

+  //=== VK_NV_cooperative_vector ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR>;
+
  //=== VK_NV_extended_sparse_address_space ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>;
@ -8151,6 +8360,16 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>;

+  //=== VK_NV_external_compute_queue ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV>;
+
  //=== VK_KHR_shader_relaxed_extended_instruction ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>;
@ -8183,6 +8402,62 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>;

+  //=== VK_NV_cluster_acceleration_structure ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV>;
+
+  //=== VK_NV_partitioned_acceleration_structure ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV>;
+
  //=== VK_EXT_device_generated_commands ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>;
@ -8253,6 +8528,16 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::DepthClampRangeEXT>;

+  //=== VK_KHR_video_maintenance2 ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>;
+
  //=== VK_HUAWEI_hdr_vivid ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI>;
@ -8271,6 +8556,16 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM>;

+#if defined( VK_USE_PLATFORM_METAL_EXT )
+  //=== VK_EXT_external_memory_metal ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT>;
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
  //=== VK_KHR_depth_clamp_zero_one ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR>;
@ -8279,8 +8574,34 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>;

+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+  //=== VK_NV_present_metering ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+  //=== VK_EXT_fragment_density_map_offset ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>;
+
+  //=================================================================
+  //=== Required exports for VULKAN_HPP_NAMESPACE::StructureChain ===
+  //=================================================================
+
+#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+  using std::tuple_element;
+  using std::tuple_size;
+#endif
 }  // namespace std

 // This VkFlags type is used as part of a bitfield in some structure.
-// As it that can't be mimiced by vk-data types, we need to export just that!!
-export VkGeometryInstanceFlagsKHR;
+// As it can't be mimicked by vk-data types, we need to export just that!!
+export using ::VkGeometryInstanceFlagsKHR;
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
--- a/include/vulkan/vulkan_enums.hpp
+++ b/include/vulkan/vulkan_enums.hpp
--- a/include/vulkan/vulkan_extension_inspection.hpp
+++ b/include/vulkan/vulkan_extension_inspection.hpp
@ -180,6 +180,7 @@ namespace VULKAN_HPP_NAMESPACE
      "VK_AMD_shader_fragment_mask",
      "VK_EXT_inline_uniform_block",
      "VK_EXT_shader_stencil_export",
+      "VK_KHR_shader_bfloat16",
      "VK_EXT_sample_locations",
      "VK_KHR_relaxed_block_layout",
      "VK_KHR_get_memory_requirements2",
@ -310,6 +311,7 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
      "VK_NV_cuda_kernel_launch",
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      "VK_QCOM_tile_shading",
      "VK_NV_low_latency",
 #if defined( VK_USE_PLATFORM_METAL_EXT )
      "VK_EXT_metal_objects",
@ -388,6 +390,7 @@ namespace VULKAN_HPP_NAMESPACE
      "VK_NV_copy_memory_indirect",
      "VK_NV_memory_decompression",
      "VK_NV_device_generated_commands_compute",
+      "VK_NV_ray_tracing_linear_swept_spheres",
      "VK_NV_linear_color_attachment",
      "VK_KHR_shader_maximal_reconvergence",
      "VK_EXT_image_compression_control_swapchain",
@ -413,6 +416,7 @@ namespace VULKAN_HPP_NAMESPACE
      "VK_SEC_amigo_profiling",
      "VK_QCOM_multiview_per_view_viewports",
      "VK_NV_ray_tracing_invocation_reorder",
+      "VK_NV_cooperative_vector",
      "VK_NV_extended_sparse_address_space",
      "VK_EXT_mutable_descriptor_type",
      "VK_EXT_legacy_vertex_attributes",
@ -447,21 +451,32 @@ namespace VULKAN_HPP_NAMESPACE
      "VK_NV_descriptor_pool_overallocation",
      "VK_KHR_video_encode_quantization_map",
      "VK_NV_raw_access_chains",
+      "VK_NV_external_compute_queue",
      "VK_KHR_shader_relaxed_extended_instruction",
      "VK_NV_command_buffer_inheritance",
      "VK_KHR_maintenance7",
      "VK_NV_shader_atomic_float16_vector",
      "VK_EXT_shader_replicated_composites",
      "VK_NV_ray_tracing_validation",
+      "VK_NV_cluster_acceleration_structure",
+      "VK_NV_partitioned_acceleration_structure",
      "VK_EXT_device_generated_commands",
      "VK_KHR_maintenance8",
      "VK_MESA_image_alignment_control",
      "VK_EXT_depth_clamp_control",
+      "VK_KHR_video_maintenance2",
      "VK_HUAWEI_hdr_vivid",
      "VK_NV_cooperative_matrix2",
      "VK_ARM_pipeline_opacity_micromap",
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+      "VK_EXT_external_memory_metal",
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
      "VK_KHR_depth_clamp_zero_one",
-      "VK_EXT_vertex_attribute_robustness"
+      "VK_EXT_vertex_attribute_robustness",
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+      "VK_NV_present_metering",
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      "VK_EXT_fragment_density_map_offset"
    };
    return deviceExtensions;
  }
@ -558,8 +573,8 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_display_swapchain",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_swapchain",
              "VK_KHR_display",
+              "VK_KHR_swapchain",
            } } } } },
 #if defined( VK_USE_PLATFORM_XLIB_KHR )
      { "VK_KHR_xlib_surface",
@ -610,10 +625,13 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_video_decode_queue",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_video_queue",
              "VK_KHR_synchronization2",
+              "VK_KHR_video_queue",
            } } },
-          { "VK_VERSION_1_3", { {} } } } },
+          { "VK_VERSION_1_3",
+            { {
+              "VK_KHR_video_queue",
+            } } } } },
      { "VK_EXT_transform_feedback",
        { { "VK_VERSION_1_0",
            { {
@ -644,6 +662,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_dynamic_rendering",
        { { "VK_VERSION_1_0",
            { {
+              "VK_KHR_depth_stencil_resolve",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -870,6 +889,7 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_image_format_list",
              "VK_KHR_maintenance2",
            } } },
          { "VK_VERSION_1_1",
@ -880,8 +900,8 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_create_renderpass2",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_multiview",
              "VK_KHR_maintenance2",
+              "VK_KHR_multiview",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
      { "VK_IMG_relaxed_line_rasterization",
@ -893,14 +913,14 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_shared_presentable_image",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_swapchain",
-              "VK_KHR_get_surface_capabilities2",
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_get_surface_capabilities2",
+              "VK_KHR_swapchain",
            } } },
          { "VK_VERSION_1_1",
            { {
-              "VK_KHR_swapchain",
              "VK_KHR_get_surface_capabilities2",
+              "VK_KHR_swapchain",
            } } } } },
      { "VK_KHR_external_fence_capabilities",
        { { "VK_VERSION_1_0",
@ -984,9 +1004,10 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_ANDROID_external_memory_android_hardware_buffer",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_sampler_ycbcr_conversion",
-              "VK_KHR_external_memory",
+              "VK_EXT_queue_family_foreign",
              "VK_KHR_dedicated_allocation",
+              "VK_KHR_external_memory",
+              "VK_KHR_sampler_ycbcr_conversion",
            } } },
          { "VK_VERSION_1_1",
            { {
@ -1003,9 +1024,11 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_AMDX_shader_enqueue",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_synchronization2",
-              "VK_KHR_spirv_1_4",
              "VK_EXT_extended_dynamic_state",
+              "VK_KHR_maintenance5",
+              "VK_KHR_pipeline_library",
+              "VK_KHR_spirv_1_4",
+              "VK_KHR_synchronization2",
            } } },
          { "VK_VERSION_1_3",
            { {
@ -1020,6 +1043,12 @@ namespace VULKAN_HPP_NAMESPACE
              "VK_KHR_maintenance1",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_shader_bfloat16",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
      { "VK_EXT_sample_locations",
        { { "VK_VERSION_1_0",
            { {
@ -1037,6 +1066,7 @@ namespace VULKAN_HPP_NAMESPACE
            { {
              "VK_EXT_descriptor_indexing",
              "VK_KHR_buffer_device_address",
+              "VK_KHR_deferred_host_operations",
            } } },
          { "VK_VERSION_1_2",
            { {
@ -1045,23 +1075,31 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_ray_tracing_pipeline",
        { { "VK_VERSION_1_0",
            { {
+              "VK_KHR_acceleration_structure",
              "VK_KHR_spirv_1_4",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
              "VK_KHR_acceleration_structure",
            } } } } },
      { "VK_KHR_ray_query",
        { { "VK_VERSION_1_0",
            { {
+              "VK_KHR_acceleration_structure",
              "VK_KHR_spirv_1_4",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
              "VK_KHR_acceleration_structure",
            } } } } },
      { "VK_NV_shader_sm_builtins", { { "VK_VERSION_1_1", { {} } } } },
      { "VK_KHR_sampler_ycbcr_conversion",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_maintenance1",
              "VK_KHR_bind_memory2",
              "VK_KHR_get_memory_requirements2",
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_maintenance1",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
      { "VK_EXT_image_drm_format_modifier",
@ -1069,6 +1107,7 @@ namespace VULKAN_HPP_NAMESPACE
            { {
              "VK_KHR_bind_memory2",
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_image_format_list",
              "VK_KHR_sampler_ycbcr_conversion",
            } } },
          { "VK_VERSION_1_1",
@ -1100,8 +1139,8 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_NV_ray_tracing",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_get_physical_device_properties2",
              "VK_KHR_get_memory_requirements2",
+              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
      { "VK_NV_representative_fragment_test",
@ -1175,8 +1214,8 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_GGP_frame_token",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_swapchain",
              "VK_GGP_stream_descriptor_surface",
+              "VK_KHR_swapchain",
            } } } } },
 #endif /*VK_USE_PLATFORM_GGP*/
      { "VK_KHR_driver_properties",
@ -1201,14 +1240,14 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_swapchain_mutable_format",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_swapchain",
-              "VK_KHR_maintenance2",
              "VK_KHR_image_format_list",
+              "VK_KHR_maintenance2",
+              "VK_KHR_swapchain",
            } } },
          { "VK_VERSION_1_1",
            { {
-              "VK_KHR_swapchain",
              "VK_KHR_image_format_list",
+              "VK_KHR_swapchain",
            } } },
          { "VK_VERSION_1_2",
            { {
@ -1278,6 +1317,8 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_get_surface_capabilities2",
+              "VK_KHR_swapchain",
            } } },
          { "VK_VERSION_1_1",
            { {
@ -1320,6 +1361,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_fragment_shading_rate",
        { { "VK_VERSION_1_0",
            { {
+              "VK_KHR_create_renderpass2",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -1353,7 +1395,11 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_shader_quad_control",
        { { "VK_VERSION_1_1",
            { {
+              "VK_KHR_shader_maximal_reconvergence",
              "VK_KHR_vulkan_memory_model",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
              "VK_KHR_shader_maximal_reconvergence",
            } } } } },
      { "VK_KHR_spirv_1_4",
@ -1388,6 +1434,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_separate_depth_stencil_layouts",
        { { "VK_VERSION_1_0",
            { {
+              "VK_KHR_create_renderpass2",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -1404,8 +1451,8 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_present_wait",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_swapchain",
              "VK_KHR_present_id",
+              "VK_KHR_swapchain",
            } } } } },
      { "VK_NV_cooperative_matrix",
        { { "VK_VERSION_1_0",
@ -1416,10 +1463,13 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_NV_coverage_reduction_mode",
        { { "VK_VERSION_1_0",
            { {
-              "VK_NV_framebuffer_mixed_samples",
              "VK_KHR_get_physical_device_properties2",
+              "VK_NV_framebuffer_mixed_samples",
            } } },
-          { "VK_VERSION_1_1", { {} } } } },
+          { "VK_VERSION_1_1",
+            { {
+              "VK_NV_framebuffer_mixed_samples",
+            } } } } },
      { "VK_EXT_fragment_shader_interlock",
        { { "VK_VERSION_1_0",
            { {
@ -1449,11 +1499,14 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_get_surface_capabilities2",
+              "VK_KHR_surface",
+              "VK_KHR_swapchain",
            } } },
          { "VK_VERSION_1_1",
            { {
-              "VK_KHR_surface",
              "VK_KHR_get_surface_capabilities2",
+              "VK_KHR_surface",
              "VK_KHR_swapchain",
            } } } } },
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
@ -1465,8 +1518,8 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_buffer_device_address",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_get_physical_device_properties2",
              "VK_KHR_device_group",
+              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
      { "VK_EXT_line_rasterization",
@ -1508,6 +1561,8 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_host_image_copy",
        { { "VK_VERSION_1_0",
            { {
+              "VK_KHR_copy_commands2",
+              "VK_KHR_format_feature_flags2",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -1530,17 +1585,21 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_surface_maintenance1",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_surface",
              "VK_KHR_get_surface_capabilities2",
+              "VK_KHR_surface",
            } } } } },
      { "VK_EXT_swapchain_maintenance1",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_swapchain",
              "VK_EXT_surface_maintenance1",
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_swapchain",
            } } },
-          { "VK_VERSION_1_1", { {} } } } },
+          { "VK_VERSION_1_1",
+            { {
+              "VK_EXT_surface_maintenance1",
+              "VK_KHR_swapchain",
+            } } } } },
      { "VK_EXT_shader_demote_to_helper_invocation",
        { { "VK_VERSION_1_0",
            { {
@ -1604,18 +1663,21 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_get_surface_capabilities2",
+              "VK_KHR_surface",
+              "VK_KHR_swapchain",
            } } },
          { "VK_VERSION_1_1",
            { {
-              "VK_KHR_surface",
              "VK_KHR_get_surface_capabilities2",
+              "VK_KHR_surface",
              "VK_KHR_swapchain",
            } } } } },
      { "VK_KHR_present_id",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_swapchain",
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_swapchain",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
      { "VK_EXT_private_data",
@ -1633,16 +1695,27 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_video_encode_queue",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_video_queue",
              "VK_KHR_synchronization2",
+              "VK_KHR_video_queue",
            } } },
-          { "VK_VERSION_1_3", { {} } } } },
+          { "VK_VERSION_1_3",
+            { {
+              "VK_KHR_video_queue",
+            } } } } },
      { "VK_NV_device_diagnostics_config",
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_QCOM_tile_shading",
+        { { "VK_VERSION_1_0",
+            { {
+                "VK_QCOM_tile_properties",
+              },
+              {
+                "VK_KHR_get_physical_device_properties2",
+              } } } } },
      { "VK_KHR_synchronization2",
        { { "VK_VERSION_1_0",
            { {
@ -1652,12 +1725,16 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_descriptor_buffer",
        { { "VK_VERSION_1_0",
            { {
+              "VK_EXT_descriptor_indexing",
+              "VK_KHR_buffer_device_address",
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_synchronization2",
            } } },
          { "VK_VERSION_1_1",
            { {
-              "VK_KHR_buffer_device_address",
              "VK_EXT_descriptor_indexing",
+              "VK_KHR_buffer_device_address",
+              "VK_KHR_synchronization2",
            } } },
          { "VK_VERSION_1_2",
            { {
@ -1668,6 +1745,7 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_pipeline_library",
            } } },
          { "VK_VERSION_1_1",
            { {
@ -1706,7 +1784,8 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_spirv_1_4",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_2", { {} } } } },
      { "VK_EXT_ycbcr_2plane_444_formats",
        { { "VK_VERSION_1_0",
            { {
@ -1812,6 +1891,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_device_address_binding_report",
        { { "VK_VERSION_1_0",
            { {
+              "VK_EXT_debug_utils",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -1845,15 +1925,15 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_FUCHSIA_external_memory",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_external_memory_capabilities",
              "VK_KHR_external_memory",
+              "VK_KHR_external_memory_capabilities",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
      { "VK_FUCHSIA_external_semaphore",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_external_semaphore_capabilities",
              "VK_KHR_external_semaphore",
+              "VK_KHR_external_semaphore_capabilities",
            } } } } },
      { "VK_FUCHSIA_buffer_collection",
        { { "VK_VERSION_1_0",
@ -1861,12 +1941,16 @@ namespace VULKAN_HPP_NAMESPACE
              "VK_FUCHSIA_external_memory",
              "VK_KHR_sampler_ycbcr_conversion",
            } } },
-          { "VK_VERSION_1_1", { {} } } } },
+          { "VK_VERSION_1_1",
+            { {
+              "VK_FUCHSIA_external_memory",
+            } } } } },
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
      { "VK_HUAWEI_subpass_shading",
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_create_renderpass2",
+              "VK_KHR_synchronization2",
            } } },
          { "VK_VERSION_1_2",
            { {
@ -1879,7 +1963,10 @@ namespace VULKAN_HPP_NAMESPACE
              "VK_KHR_ray_tracing_pipeline",
              "VK_KHR_synchronization2",
            } } },
-          { "VK_VERSION_1_3", { {} } } } },
+          { "VK_VERSION_1_3",
+            { {
+              "VK_KHR_ray_tracing_pipeline",
+            } } } } },
      { "VK_NV_external_memory_rdma",
        { { "VK_VERSION_1_0",
            { {
@ -1934,7 +2021,10 @@ namespace VULKAN_HPP_NAMESPACE
              "VK_EXT_global_priority",
              "VK_KHR_get_physical_device_properties2",
            } } },
-          { "VK_VERSION_1_1", { {} } } } },
+          { "VK_VERSION_1_1",
+            { {
+              "VK_EXT_global_priority",
+            } } } } },
      { "VK_EXT_image_view_min_lod",
        { { "VK_VERSION_1_0",
            { {
@ -1950,8 +2040,8 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_image_2d_view_of_3d",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_maintenance1",
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_maintenance1",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
      { "VK_EXT_shader_tile_image", { { "VK_VERSION_1_3", { {} } } } },
@ -1961,7 +2051,10 @@ namespace VULKAN_HPP_NAMESPACE
              "VK_KHR_acceleration_structure",
              "VK_KHR_synchronization2",
            } } },
-          { "VK_VERSION_1_3", { {} } } } },
+          { "VK_VERSION_1_3",
+            { {
+              "VK_KHR_acceleration_structure",
+            } } } } },
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
      { "VK_NV_displacement_micromap",
        { { "VK_VERSION_1_0",
@ -1995,8 +2088,8 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_image_sliced_view_of_3d",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_maintenance1",
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_maintenance1",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
      { "VK_VALVE_descriptor_set_host_mapping",
@ -2021,6 +2114,7 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_synchronization2",
            } } },
          { "VK_VERSION_1_1",
            { {
@ -2030,6 +2124,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_QCOM_fragment_density_map_offset",
        { { "VK_VERSION_1_0",
            { {
+              "VK_EXT_fragment_density_map",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -2039,6 +2134,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_NV_copy_memory_indirect",
        { { "VK_VERSION_1_0",
            { {
+              "VK_KHR_buffer_device_address",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -2049,6 +2145,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_NV_memory_decompression",
        { { "VK_VERSION_1_0",
            { {
+              "VK_KHR_buffer_device_address",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -2061,6 +2158,11 @@ namespace VULKAN_HPP_NAMESPACE
            { {
              "VK_NV_device_generated_commands",
            } } } } },
+      { "VK_NV_ray_tracing_linear_swept_spheres",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_ray_tracing_pipeline",
+            } } } } },
      { "VK_NV_linear_color_attachment",
        { { "VK_VERSION_1_0",
            { {
@ -2111,6 +2213,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_shader_module_identifier",
        { { "VK_VERSION_1_0",
            { {
+              "VK_EXT_pipeline_creation_cache_control",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -2127,7 +2230,9 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_NV_optical_flow",
        { { "VK_VERSION_1_0",
            { {
+              "VK_KHR_format_feature_flags2",
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_synchronization2",
            } } },
          { "VK_VERSION_1_1",
            { {
@ -2168,6 +2273,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_shader_object",
        { { "VK_VERSION_1_0",
            { {
+              "VK_KHR_dynamic_rendering",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -2179,7 +2285,8 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_maintenance5",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_4", { {} } } } },
      { "VK_QCOM_tile_properties",
        { { "VK_VERSION_1_0",
            { {
@ -2207,7 +2314,8 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_maintenance3",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
      { "VK_EXT_legacy_vertex_attributes",
        { { "VK_VERSION_1_0",
            { {
@ -2222,12 +2330,13 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_pipeline_library_group_handles",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_ray_tracing_pipeline",
              "VK_KHR_pipeline_library",
+              "VK_KHR_ray_tracing_pipeline",
            } } } } },
      { "VK_EXT_dynamic_rendering_unused_attachments",
        { { "VK_VERSION_1_0",
            { {
+              "VK_KHR_dynamic_rendering",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -2251,7 +2360,8 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_get_physical_device_properties2",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
      { "VK_KHR_video_decode_av1",
        { { "VK_VERSION_1_0",
            { {
@ -2296,6 +2406,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_attachment_feedback_loop_dynamic_state",
        { { "VK_VERSION_1_0",
            { {
+              "VK_EXT_attachment_feedback_loop_layout",
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1",
@ -2317,9 +2428,10 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_QNX_external_memory_screen_buffer",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_sampler_ycbcr_conversion",
-              "VK_KHR_external_memory",
+              "VK_EXT_queue_family_foreign",
              "VK_KHR_dedicated_allocation",
+              "VK_KHR_external_memory",
+              "VK_KHR_sampler_ycbcr_conversion",
            } } },
          { "VK_VERSION_1_1",
            { {
@ -2367,16 +2479,35 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_video_encode_quantization_map",
        { { "VK_VERSION_1_0",
            { {
-              "VK_KHR_video_encode_queue",
              "VK_KHR_format_feature_flags2",
+              "VK_KHR_video_encode_queue",
+            } } },
+          { "VK_VERSION_1_3",
+            { {
+              "VK_KHR_video_encode_queue",
            } } } } },
      { "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_cluster_acceleration_structure",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_acceleration_structure",
+            } } } } },
+      { "VK_NV_partitioned_acceleration_structure",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_acceleration_structure",
+            } } } } },
      { "VK_EXT_device_generated_commands",
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_buffer_device_address",
              "VK_KHR_maintenance5",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_2",
+            { {
+              "VK_KHR_maintenance5",
+            } } },
+          { "VK_VERSION_1_3", { {} } } } },
      { "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } },
      { "VK_MESA_image_alignment_control",
        { { "VK_VERSION_1_0",
@ -2390,15 +2521,22 @@ namespace VULKAN_HPP_NAMESPACE
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_video_maintenance2",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_video_queue",
+            } } } } },
      { "VK_HUAWEI_hdr_vivid",
        { { "VK_VERSION_1_0",
            { {
+              "VK_EXT_hdr_metadata",
              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_swapchain",
            } } },
          { "VK_VERSION_1_1",
            { {
-              "VK_KHR_swapchain",
              "VK_EXT_hdr_metadata",
+              "VK_KHR_swapchain",
            } } } } },
      { "VK_NV_cooperative_matrix2",
        { { "VK_VERSION_1_0",
@ -2410,6 +2548,14 @@ namespace VULKAN_HPP_NAMESPACE
            { {
              "VK_EXT_opacity_micromap",
            } } } } },
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+      { "VK_EXT_external_memory_metal",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_external_memory",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
      { "VK_KHR_depth_clamp_zero_one",
        { { "VK_VERSION_1_0",
            { {
@ -2421,7 +2567,30 @@ namespace VULKAN_HPP_NAMESPACE
            { {
              "VK_KHR_get_physical_device_properties2",
            } } },
-          { "VK_VERSION_1_1", { {} } } } }
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_fragment_density_map_offset",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_EXT_fragment_density_map",
+              "VK_KHR_create_renderpass2",
+              "VK_KHR_dynamic_rendering",
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1",
+            { {
+              "VK_EXT_fragment_density_map",
+              "VK_KHR_create_renderpass2",
+              "VK_KHR_dynamic_rendering",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
+              "VK_EXT_fragment_density_map",
+              "VK_KHR_dynamic_rendering",
+            } } },
+          { "VK_VERSION_1_3",
+            { {
+              "VK_EXT_fragment_density_map",
+            } } } } }
    };
    auto depIt = dependencies.find( extension );
    return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
@ -2559,6 +2728,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_maintenance4", "VK_VERSION_1_3" },
      { "VK_KHR_shader_subgroup_rotate", "VK_VERSION_1_4" },
      { "VK_EXT_depth_clamp_zero_one", "VK_KHR_depth_clamp_zero_one" },
+      { "VK_QCOM_fragment_density_map_offset", "VK_EXT_fragment_density_map_offset" },
      { "VK_EXT_pipeline_protected_access", "VK_VERSION_1_4" },
      { "VK_KHR_maintenance5", "VK_VERSION_1_4" },
      { "VK_KHR_vertex_attribute_divisor", "VK_VERSION_1_4" },
@ -3032,6 +3202,10 @@ namespace VULKAN_HPP_NAMESPACE
    {
      return "VK_KHR_depth_clamp_zero_one";
    }
+    if ( extension == "VK_QCOM_fragment_density_map_offset" )
+    {
+      return "VK_EXT_fragment_density_map_offset";
+    }
    if ( extension == "VK_EXT_pipeline_protected_access" )
    {
      return "VK_VERSION_1_4";
@ -3147,8 +3321,8 @@ namespace VULKAN_HPP_NAMESPACE
        || ( extension == "VK_AMDX_shader_enqueue" )
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
        || ( extension == "VK_AMD_mixed_attachment_samples" ) || ( extension == "VK_AMD_shader_fragment_mask" ) ||
-           ( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_EXT_sample_locations" ) ||
-           ( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
+           ( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_KHR_shader_bfloat16" ) ||
+           ( extension == "VK_EXT_sample_locations" ) || ( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
           ( extension == "VK_KHR_image_format_list" ) || ( extension == "VK_EXT_blend_operation_advanced" ) ||
           ( extension == "VK_NV_fragment_coverage_to_color" ) || ( extension == "VK_KHR_acceleration_structure" ) ||
           ( extension == "VK_KHR_ray_tracing_pipeline" ) || ( extension == "VK_KHR_ray_query" ) || ( extension == "VK_NV_framebuffer_mixed_samples" ) ||
@ -3211,7 +3385,7 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
        || ( extension == "VK_NV_cuda_kernel_launch" )
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-        || ( extension == "VK_NV_low_latency" )
+        || ( extension == "VK_QCOM_tile_shading" ) || ( extension == "VK_NV_low_latency" )
 #if defined( VK_USE_PLATFORM_METAL_EXT )
        || ( extension == "VK_EXT_metal_objects" )
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
@ -3253,25 +3427,27 @@ namespace VULKAN_HPP_NAMESPACE
           ( extension == "VK_EXT_non_seamless_cube_map" ) || ( extension == "VK_ARM_render_pass_striped" ) ||
           ( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_NV_copy_memory_indirect" ) ||
           ( extension == "VK_NV_memory_decompression" ) || ( extension == "VK_NV_device_generated_commands_compute" ) ||
-           ( extension == "VK_NV_linear_color_attachment" ) || ( extension == "VK_KHR_shader_maximal_reconvergence" ) ||
-           ( extension == "VK_EXT_image_compression_control_swapchain" ) || ( extension == "VK_QCOM_image_processing" ) ||
-           ( extension == "VK_EXT_nested_command_buffer" ) || ( extension == "VK_EXT_external_memory_acquire_unmodified" ) ||
-           ( extension == "VK_EXT_extended_dynamic_state3" ) || ( extension == "VK_EXT_subpass_merge_feedback" ) ||
-           ( extension == "VK_EXT_shader_module_identifier" ) || ( extension == "VK_EXT_rasterization_order_attachment_access" ) ||
-           ( extension == "VK_NV_optical_flow" ) || ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" )
+           ( extension == "VK_NV_ray_tracing_linear_swept_spheres" ) || ( extension == "VK_NV_linear_color_attachment" ) ||
+           ( extension == "VK_KHR_shader_maximal_reconvergence" ) || ( extension == "VK_EXT_image_compression_control_swapchain" ) ||
+           ( extension == "VK_QCOM_image_processing" ) || ( extension == "VK_EXT_nested_command_buffer" ) ||
+           ( extension == "VK_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) ||
+           ( extension == "VK_EXT_subpass_merge_feedback" ) || ( extension == "VK_EXT_shader_module_identifier" ) ||
+           ( extension == "VK_EXT_rasterization_order_attachment_access" ) || ( extension == "VK_NV_optical_flow" ) ||
+           ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" )
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
        || ( extension == "VK_ANDROID_external_format_resolve" )
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
        || ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) ||
           ( extension == "VK_EXT_shader_object" ) || ( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) ||
           ( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
-           ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_NV_extended_sparse_address_space" ) ||
-           ( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_EXT_legacy_vertex_attributes" ) ||
-           ( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) ||
-           ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_NV_low_latency2" ) ||
-           ( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_QCOM_multiview_per_view_render_areas" ) ||
-           ( extension == "VK_KHR_compute_shader_derivatives" ) || ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) ||
-           ( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) ||
+           ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_NV_cooperative_vector" ) ||
+           ( extension == "VK_NV_extended_sparse_address_space" ) || ( extension == "VK_EXT_mutable_descriptor_type" ) ||
+           ( extension == "VK_EXT_legacy_vertex_attributes" ) || ( extension == "VK_ARM_shader_core_builtins" ) ||
+           ( extension == "VK_EXT_pipeline_library_group_handles" ) || ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) ||
+           ( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) ||
+           ( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_compute_shader_derivatives" ) ||
+           ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) || ( extension == "VK_KHR_video_maintenance1" ) ||
+           ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) ||
           ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) ||
           ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) ||
           ( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_shader_float_controls2" )
@ -3281,13 +3457,23 @@ namespace VULKAN_HPP_NAMESPACE
        || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
           ( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||
           ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_KHR_video_encode_quantization_map" ) ||
-           ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) ||
-           ( extension == "VK_NV_command_buffer_inheritance" ) || ( extension == "VK_KHR_maintenance7" ) ||
-           ( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) ||
-           ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) ||
-           ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) ||
-           ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" ) ||
-           ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" );
+           ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_NV_external_compute_queue" ) ||
+           ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) ||
+           ( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) ||
+           ( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
+           ( extension == "VK_NV_cluster_acceleration_structure" ) || ( extension == "VK_NV_partitioned_acceleration_structure" ) ||
+           ( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) ||
+           ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
+           ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) ||
+           ( extension == "VK_ARM_pipeline_opacity_micromap" )
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+        || ( extension == "VK_EXT_external_memory_metal" )
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+        || ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" )
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+        || ( extension == "VK_NV_present_metering" )
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+        || ( extension == "VK_EXT_fragment_density_map_offset" );
  }

  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
@ -3398,8 +3584,8 @@ namespace VULKAN_HPP_NAMESPACE
           ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) ||
           ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" ) ||
           ( extension == "VK_KHR_shader_subgroup_rotate" ) || ( extension == "VK_EXT_depth_clamp_zero_one" ) ||
-           ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
-           ( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
+           ( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_EXT_pipeline_protected_access" ) ||
+           ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
           ( extension == "VK_KHR_shader_float_controls2" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
           ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" );
  }
--- a/include/vulkan/vulkan_format_traits.hpp
+++ b/include/vulkan/vulkan_format_traits.hpp
@ -4662,7 +4662,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eB8G8R8A8Unorm:
@ -4725,7 +4725,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eA8B8G8R8UnormPack32:
@ -4785,7 +4785,7 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::Format::eA8B8G8R8SrgbPack32:
        switch ( component )
        {
-          case 0: return "SRGB";
+          case 0: return "UNORM";
          case 1: return "SRGB";
          case 2: return "SRGB";
          case 3: return "SRGB";
@ -5381,7 +5381,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eBc2UnormBlock:
@ -5399,7 +5399,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eBc3UnormBlock:
@ -5417,7 +5417,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eBc4UnormBlock:
@ -5477,7 +5477,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8UnormBlock:
@ -5511,7 +5511,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8UnormBlock:
@ -5529,7 +5529,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eEacR11UnormBlock:
@ -5573,7 +5573,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc5x4UnormBlock:
@ -5591,7 +5591,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc5x5UnormBlock:
@ -5609,7 +5609,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc6x5UnormBlock:
@ -5627,7 +5627,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc6x6UnormBlock:
@ -5645,7 +5645,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc8x5UnormBlock:
@ -5663,7 +5663,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc8x6UnormBlock:
@ -5681,7 +5681,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc8x8UnormBlock:
@ -5699,7 +5699,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x5UnormBlock:
@ -5717,7 +5717,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x6UnormBlock:
@ -5735,7 +5735,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x8UnormBlock:
@ -5753,7 +5753,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x10UnormBlock:
@ -5771,7 +5771,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x10UnormBlock:
@ -5789,7 +5789,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x12UnormBlock:
@ -5807,7 +5807,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eG8B8G8R8422Unorm:
@ -6319,7 +6319,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG:
@ -6328,7 +6328,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG:
@ -6337,7 +6337,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG:
@ -6346,7 +6346,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
--- a/include/vulkan/vulkan_funcs.hpp
+++ b/include/vulkan/vulkan_funcs.hpp
--- a/include/vulkan/vulkan_handles.hpp
+++ b/include/vulkan/vulkan_handles.hpp
--- a/include/vulkan/vulkan_hash.hpp
+++ b/include/vulkan/vulkan_hash.hpp
--- a/include/vulkan/vulkan_metal.h
+++ b/include/vulkan/vulkan_metal.h
@ -188,6 +188,47 @@ VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(
    VkExportMetalObjectsInfoEXT*                pMetalObjectsInfo);
 #endif

+
+// VK_EXT_external_memory_metal is a preprocessor guard. Do not pass it to API calls.
+#define VK_EXT_external_memory_metal 1
+#define VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION 1
+#define VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME "VK_EXT_external_memory_metal"
+typedef struct VkImportMemoryMetalHandleInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    void*                                 handle;
+} VkImportMemoryMetalHandleInfoEXT;
+
+typedef struct VkMemoryMetalHandlePropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryMetalHandlePropertiesEXT;
+
+typedef struct VkMemoryGetMetalHandleInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetMetalHandleInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandleEXT)(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandlePropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(
+    VkDevice                                    device,
+    const VkMemoryGetMetalHandleInfoEXT*        pGetMetalHandleInfo,
+    void**                                      pHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    const void*                                 pHandle,
+    VkMemoryMetalHandlePropertiesEXT*           pMemoryMetalHandleProperties);
+#endif
+
 #ifdef __cplusplus
 }
 #endif
--- a/include/vulkan/vulkan_raii.hpp
+++ b/include/vulkan/vulkan_raii.hpp
--- a/include/vulkan/vulkan_shared.hpp
+++ b/include/vulkan/vulkan_shared.hpp
@ -315,6 +315,9 @@ namespace VULKAN_HPP_NAMESPACE
 #  if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
 #    pragma GCC diagnostic push
 #    pragma GCC diagnostic ignored "-Wcast-function-type"
+#  elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wcast-function-type"
 #  endif

    template <typename HandleType>
@ -459,6 +462,8 @@ namespace VULKAN_HPP_NAMESPACE

 #  if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
 #    pragma GCC diagnostic pop
+#  elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
+#    pragma clang diagnostic pop
 #  endif

  }  // namespace detail
@ -976,6 +981,17 @@ namespace VULKAN_HPP_NAMESPACE

  using SharedPipelineBinaryKHR = SharedHandle<PipelineBinaryKHR>;

+  //=== VK_NV_external_compute_queue ===
+  template <>
+  class SharedHandleTraits<ExternalComputeQueueNV>
+  {
+  public:
+    using DestructorType = Device;
+    using deleter        = detail::ObjectDestroyShared<ExternalComputeQueueNV>;
+  };
+
+  using SharedExternalComputeQueueNV = SharedHandle<ExternalComputeQueueNV>;
+
  //=== VK_EXT_device_generated_commands ===
  template <>
  class SharedHandleTraits<IndirectCommandsLayoutEXT>
--- a/include/vulkan/vulkan_static_assertions.hpp
+++ b/include/vulkan/vulkan_static_assertions.hpp
@ -3611,6 +3611,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Attachme
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>::value,
                          "AttachmentSampleCountInfoAMD is not nothrow_move_constructible!" );

+//=== VK_KHR_shader_bfloat16 ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderBfloat16FeaturesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>::value,
+                          "PhysicalDeviceShaderBfloat16FeaturesKHR is not nothrow_move_constructible!" );
+
 //=== VK_EXT_sample_locations ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
@ -5393,6 +5402,44 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
                          "PhysicalDeviceCudaKernelLaunchPropertiesNV is not nothrow_move_constructible!" );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+//=== VK_QCOM_tile_shading ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM ) == sizeof( VkPhysicalDeviceTileShadingFeaturesQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM>::value,
+                          "PhysicalDeviceTileShadingFeaturesQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM ) == sizeof( VkPhysicalDeviceTileShadingPropertiesQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM>::value,
+                          "PhysicalDeviceTileShadingPropertiesQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM ) == sizeof( VkRenderPassTileShadingCreateInfoQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM>::value,
+                          "RenderPassTileShadingCreateInfoQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM ) == sizeof( VkPerTileBeginInfoQCOM ), "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM>::value,
+                          "PerTileBeginInfoQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM ) == sizeof( VkPerTileEndInfoQCOM ), "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM>::value,
+                          "PerTileEndInfoQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM ) == sizeof( VkDispatchTileInfoQCOM ), "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM>::value,
+                          "DispatchTileInfoQCOM is not nothrow_move_constructible!" );
+
 //=== VK_NV_low_latency ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV ) == sizeof( VkQueryLowLatencySupportNV ),
@ -6595,31 +6642,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPa
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>::value,
                          "RenderPassStripeSubmitInfoARM is not nothrow_move_constructible!" );

-//=== VK_QCOM_fragment_density_map_offset ===
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) ==
-                            sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ),
-                          "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
-                          "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
-                          "PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM is not nothrow_move_constructible!" );
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) ==
-                            sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ),
-                          "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
-                          "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
-                          "PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM is not nothrow_move_constructible!" );
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM ) == sizeof( VkSubpassFragmentDensityMapOffsetEndInfoQCOM ),
-                          "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
-                          "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
-                          "SubpassFragmentDensityMapOffsetEndInfoQCOM is not nothrow_move_constructible!" );
-
 //=== VK_NV_copy_memory_indirect ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV ) == sizeof( VkCopyMemoryIndirectCommandNV ),
@ -6704,6 +6726,31 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::BindPipe
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV>::value,
                          "BindPipelineIndirectCommandNV is not nothrow_move_constructible!" );

+//=== VK_NV_ray_tracing_linear_swept_spheres ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV ) ==
+                            sizeof( VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>::value,
+                          "PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV ) ==
+                            sizeof( VkAccelerationStructureGeometryLinearSweptSpheresDataNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV>::value,
+                          "AccelerationStructureGeometryLinearSweptSpheresDataNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV ) == sizeof( VkAccelerationStructureGeometrySpheresDataNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV>::value,
+                          "AccelerationStructureGeometrySpheresDataNV is not nothrow_move_constructible!" );
+
 //=== VK_NV_linear_color_attachment ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV ) ==
@ -7197,6 +7244,36 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV>::value,
                          "PhysicalDeviceRayTracingInvocationReorderFeaturesNV is not nothrow_move_constructible!" );

+//=== VK_NV_cooperative_vector ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV ) ==
+                            sizeof( VkPhysicalDeviceCooperativeVectorPropertiesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV>::value,
+                          "PhysicalDeviceCooperativeVectorPropertiesNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeVectorFeaturesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV>::value,
+                          "PhysicalDeviceCooperativeVectorFeaturesNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV ) == sizeof( VkCooperativeVectorPropertiesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV>::value,
+                          "CooperativeVectorPropertiesNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV ) == sizeof( VkConvertCooperativeVectorMatrixInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV>::value,
+                          "ConvertCooperativeVectorMatrixInfoNV is not nothrow_move_constructible!" );
+
 //=== VK_NV_extended_sparse_address_space ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV ) ==
@ -7826,6 +7903,42 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>::value,
                          "PhysicalDeviceRawAccessChainsFeaturesNV is not nothrow_move_constructible!" );

+//=== VK_NV_external_compute_queue ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV ) == sizeof( VkExternalComputeQueueNV ),
+                          "handle and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>::value,
+                          "ExternalComputeQueueNV is not copy_constructible!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>::value,
+                          "ExternalComputeQueueNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV ) == sizeof( VkExternalComputeQueueDeviceCreateInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV>::value,
+                          "ExternalComputeQueueDeviceCreateInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV ) == sizeof( VkExternalComputeQueueCreateInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV>::value,
+                          "ExternalComputeQueueCreateInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV ) == sizeof( VkExternalComputeQueueDataParamsNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV>::value,
+                          "ExternalComputeQueueDataParamsNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV ) ==
+                            sizeof( VkPhysicalDeviceExternalComputeQueuePropertiesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV>::value,
+                          "PhysicalDeviceExternalComputeQueuePropertiesNV is not nothrow_move_constructible!" );
+
 //=== VK_KHR_shader_relaxed_extended_instruction ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ) ==
@ -7914,6 +8027,212 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>::value,
                          "PhysicalDeviceRayTracingValidationFeaturesNV is not nothrow_move_constructible!" );

+//=== VK_NV_cluster_acceleration_structure ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV ) ==
+                            sizeof( VkPhysicalDeviceClusterAccelerationStructureFeaturesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV>::value,
+                          "PhysicalDeviceClusterAccelerationStructureFeaturesNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV ) ==
+                            sizeof( VkPhysicalDeviceClusterAccelerationStructurePropertiesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV>::value,
+                          "PhysicalDeviceClusterAccelerationStructurePropertiesNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV ) ==
+                            sizeof( VkClusterAccelerationStructureClustersBottomLevelInputNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV>::value,
+                          "ClusterAccelerationStructureClustersBottomLevelInputNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV ) ==
+                            sizeof( VkClusterAccelerationStructureTriangleClusterInputNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV>::value,
+                          "ClusterAccelerationStructureTriangleClusterInputNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV ) ==
+                            sizeof( VkClusterAccelerationStructureMoveObjectsInputNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV>::value,
+                          "ClusterAccelerationStructureMoveObjectsInputNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV ) == sizeof( VkClusterAccelerationStructureOpInputNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV>::value,
+                          "ClusterAccelerationStructureOpInputNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV ) == sizeof( VkClusterAccelerationStructureInputInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV>::value,
+                          "ClusterAccelerationStructureInputInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV ) == sizeof( VkClusterAccelerationStructureCommandsInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV>::value,
+                          "ClusterAccelerationStructureCommandsInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV ) == sizeof( VkStridedDeviceAddressNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV>::value,
+                          "StridedDeviceAddressNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV ) ==
+                            sizeof( VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>::value,
+                          "ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV ) ==
+                            sizeof( VkClusterAccelerationStructureMoveObjectsInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV>::value,
+                          "ClusterAccelerationStructureMoveObjectsInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV ) ==
+                            sizeof( VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV>::value,
+                          "ClusterAccelerationStructureBuildClustersBottomLevelInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV ) ==
+                            sizeof( VkClusterAccelerationStructureBuildTriangleClusterInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV>::value,
+                          "ClusterAccelerationStructureBuildTriangleClusterInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV ) ==
+                            sizeof( VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV>::value,
+                          "ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV ) ==
+                            sizeof( VkClusterAccelerationStructureInstantiateClusterInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV>::value,
+                          "ClusterAccelerationStructureInstantiateClusterInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV ) ==
+                            sizeof( VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV>::value,
+                          "RayTracingPipelineClusterAccelerationStructureCreateInfoNV is not nothrow_move_constructible!" );
+
+//=== VK_NV_partitioned_acceleration_structure ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV ) ==
+                            sizeof( VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV>::value,
+                          "PhysicalDevicePartitionedAccelerationStructureFeaturesNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV ) ==
+                            sizeof( VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV>::value,
+                          "PhysicalDevicePartitionedAccelerationStructurePropertiesNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV ) == sizeof( VkPartitionedAccelerationStructureFlagsNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV>::value,
+                          "PartitionedAccelerationStructureFlagsNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV ) ==
+                            sizeof( VkBuildPartitionedAccelerationStructureIndirectCommandNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV>::value,
+                          "BuildPartitionedAccelerationStructureIndirectCommandNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV ) ==
+                            sizeof( VkPartitionedAccelerationStructureWriteInstanceDataNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV>::value,
+                          "PartitionedAccelerationStructureWriteInstanceDataNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV ) ==
+                            sizeof( VkPartitionedAccelerationStructureUpdateInstanceDataNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV>::value,
+                          "PartitionedAccelerationStructureUpdateInstanceDataNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV ) ==
+                            sizeof( VkPartitionedAccelerationStructureWritePartitionTranslationDataNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV>::value,
+                          "PartitionedAccelerationStructureWritePartitionTranslationDataNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV ) ==
+                            sizeof( VkWriteDescriptorSetPartitionedAccelerationStructureNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV>::value,
+                          "WriteDescriptorSetPartitionedAccelerationStructureNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV ) ==
+                            sizeof( VkPartitionedAccelerationStructureInstancesInputNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV>::value,
+                          "PartitionedAccelerationStructureInstancesInputNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV ) ==
+                            sizeof( VkBuildPartitionedAccelerationStructureInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV>::value,
+                          "BuildPartitionedAccelerationStructureInfoNV is not nothrow_move_constructible!" );
+
 //=== VK_EXT_device_generated_commands ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT ) ==
@ -8146,6 +8465,39 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DepthCla
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DepthClampRangeEXT>::value,
                          "DepthClampRangeEXT is not nothrow_move_constructible!" );

+//=== VK_KHR_video_maintenance2 ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance2FeaturesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR>::value,
+                          "PhysicalDeviceVideoMaintenance2FeaturesKHR is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR ) ==
+                            sizeof( VkVideoDecodeH264InlineSessionParametersInfoKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR>::value,
+                          "VideoDecodeH264InlineSessionParametersInfoKHR is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR ) ==
+                            sizeof( VkVideoDecodeH265InlineSessionParametersInfoKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>::value,
+                          "VideoDecodeH265InlineSessionParametersInfoKHR is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR ) ==
+                            sizeof( VkVideoDecodeAV1InlineSessionParametersInfoKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>::value,
+                          "VideoDecodeAV1InlineSessionParametersInfoKHR is not nothrow_move_constructible!" );
+
 //=== VK_HUAWEI_hdr_vivid ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI ) == sizeof( VkPhysicalDeviceHdrVividFeaturesHUAWEI ),
@ -8196,6 +8548,28 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM>::value,
                          "PhysicalDevicePipelineOpacityMicromapFeaturesARM is not nothrow_move_constructible!" );

+#if defined( VK_USE_PLATFORM_METAL_EXT )
+//=== VK_EXT_external_memory_metal ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT ) == sizeof( VkImportMemoryMetalHandleInfoEXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT>::value,
+                          "ImportMemoryMetalHandleInfoEXT is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT ) == sizeof( VkMemoryMetalHandlePropertiesEXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>::value,
+                          "MemoryMetalHandlePropertiesEXT is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT ) == sizeof( VkMemoryGetMetalHandleInfoEXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT>::value,
+                          "MemoryGetMetalHandleInfoEXT is not nothrow_move_constructible!" );
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
 //=== VK_KHR_depth_clamp_zero_one ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR ) == sizeof( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR ),
@ -8215,4 +8589,51 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>::value,
                          "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT is not nothrow_move_constructible!" );

+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+//=== VK_NV_present_metering ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetPresentConfigNV ) == sizeof( VkSetPresentConfigNV ), "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>::value,
+                          "SetPresentConfigNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV ) == sizeof( VkPhysicalDevicePresentMeteringFeaturesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>::value,
+                          "PhysicalDevicePresentMeteringFeaturesNV is not nothrow_move_constructible!" );
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+//=== VK_EXT_fragment_density_map_offset ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT ) == sizeof( VkRenderingEndInfoEXT ), "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>::value,
+                          "RenderingEndInfoEXT is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ) ==
+                            sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>::value,
+                          "PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ) ==
+                            sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>::value,
+                          "PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT ) ==
+                            sizeof( VkRenderPassFragmentDensityMapOffsetEndInfoEXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>::value,
+                          "RenderPassFragmentDensityMapOffsetEndInfoEXT is not nothrow_move_constructible!" );
+
 #endif
--- a/include/vulkan/vulkan_structs.hpp
+++ b/include/vulkan/vulkan_structs.hpp
--- a/include/vulkan/vulkan_to_string.hpp
+++ b/include/vulkan/vulkan_to_string.hpp
--- a/include/vulkan/vulkan_video.hpp
+++ b/include/vulkan/vulkan_video.hpp
--- a/registry/base_generator.py
+++ b/registry/base_generator.py
@ -0,0 +1,803 @@
+#!/usr/bin/env python3 -i
+#
+# Copyright 2023-2025 The Khronos Group Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import pickle
+import os
+import tempfile
+from vulkan_object import (VulkanObject,
+    Extension, Version, Handle, Param, Queues, CommandScope, Command,
+    EnumField, Enum, Flag, Bitmask, Member, Struct,
+    FormatComponent, FormatPlane, Format,
+    SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline,
+    SpirvEnables, Spirv)
+
+# These live in the Vulkan-Docs repo, but are pulled in via the
+# Vulkan-Headers/registry folder
+from generator import OutputGenerator, GeneratorOptions, write
+from vkconventions import VulkanConventions
+
+# An API style convention object
+vulkanConventions = VulkanConventions()
+
+# Helpers to keep things cleaner
+def splitIfGet(elem, name):
+    return elem.get(name).split(',') if elem.get(name) is not None and elem.get(name) != '' else None
+
+def textIfFind(elem, name):
+    return elem.find(name).text if elem.find(name) is not None else None
+
+def intIfGet(elem, name):
+    return None if elem.get(name) is None else int(elem.get(name), 0)
+
+def boolGet(elem, name) -> bool:
+    return elem.get(name) is not None and elem.get(name) == "true"
+
+def getQueues(elem) -> Queues:
+    queues = 0
+    queues_list = splitIfGet(elem, 'queues')
+    if queues_list is not None:
+        queues |= Queues.TRANSFER if 'transfer' in queues_list else 0
+        queues |= Queues.GRAPHICS if 'graphics' in queues_list else 0
+        queues |= Queues.COMPUTE if 'compute' in queues_list else 0
+        queues |= Queues.PROTECTED if 'protected' in queues_list else 0
+        queues |= Queues.SPARSE_BINDING if 'sparse_binding' in queues_list else 0
+        queues |= Queues.OPTICAL_FLOW if 'opticalflow' in queues_list else 0
+        queues |= Queues.DECODE if 'decode' in queues_list else 0
+        queues |= Queues.ENCODE if 'encode' in queues_list else 0
+    return queues
+
+# Shared object used by Sync elements that do not have ones
+maxSyncSupport = SyncSupport(None, None, True)
+maxSyncEquivalent = SyncEquivalent(None, None, True)
+
+# Helpers to set GeneratorOptions options globally
+def SetOutputFileName(fileName: str) -> None:
+    global globalFileName
+    globalFileName = fileName
+
+def SetOutputDirectory(directory: str) -> None:
+    global globalDirectory
+    globalDirectory = directory
+
+def SetTargetApiName(apiname: str) -> None:
+    global globalApiName
+    globalApiName = apiname
+
+def SetMergedApiNames(names: str) -> None:
+    global mergedApiNames
+    mergedApiNames = names
+
+cachingEnabled = False
+def EnableCaching() -> None:
+    global cachingEnabled
+    cachingEnabled = True
+
+# This class is a container for any source code, data, or other behavior that is necessary to
+# customize the generator script for a specific target API variant (e.g. Vulkan SC). As such,
+# all of these API-specific interfaces and their use in the generator script are part of the
+# contract between this repository and its downstream users. Changing or removing any of these
+# interfaces or their use in the generator script will have downstream effects and thus
+# should be avoided unless absolutely necessary.
+class APISpecific:
+    # Version object factory method
+    @staticmethod
+    def createApiVersion(targetApiName: str, name: str) -> Version:
+        match targetApiName:
+
+            # Vulkan SC specific API version creation
+            case 'vulkansc':
+                nameApi = name.replace('VK_', 'VK_API_')
+                nameApi = nameApi.replace('VKSC_', 'VKSC_API_')
+                nameString = f'"{name}"'
+                return Version(name, nameString, nameApi)
+
+            # Vulkan specific API version creation
+            case 'vulkan':
+                nameApi = name.replace('VK_', 'VK_API_')
+                nameString = f'"{name}"'
+                return Version(name, nameString, nameApi)
+
+
+# This Generator Option is used across all generators.
+# After years of use, it has shown that most the options are unified across each generator (file)
+# as it is easier to modify things per-file that need the difference
+class BaseGeneratorOptions(GeneratorOptions):
+    def __init__(self,
+                 customFileName = None,
+                 customDirectory = None,
+                 customApiName = None):
+        GeneratorOptions.__init__(self,
+                conventions = vulkanConventions,
+                filename = customFileName if customFileName else globalFileName,
+                directory = customDirectory if customDirectory else globalDirectory,
+                apiname = customApiName if customApiName else globalApiName,
+                mergeApiNames = mergedApiNames,
+                defaultExtensions = customApiName if customApiName else globalApiName,
+                emitExtensions = '.*',
+                emitSpirv = '.*',
+                emitFormats = '.*')
+        # These are used by the generator.py script
+        self.apicall         = 'VKAPI_ATTR '
+        self.apientry        = 'VKAPI_CALL '
+        self.apientryp       = 'VKAPI_PTR *'
+        self.alignFuncParam  = 48
+
+#
+# This object handles all the parsing from reg.py generator scripts in the Vulkan-Headers
+# It will grab all the data and form it into a single object the rest of the generators will use
+class BaseGenerator(OutputGenerator):
+    def __init__(self):
+        OutputGenerator.__init__(self, None, None, None)
+        self.vk = VulkanObject()
+        self.targetApiName = globalApiName
+
+        # reg.py has a `self.featureName` but this is nicer because
+        # it will be either the Version or Extension object
+        self.currentExtension = None
+        self.currentVersion = None
+
+        # Will map alias to promoted name
+        #   ex. ['VK_FILTER_CUBIC_IMG' : 'VK_FILTER_CUBIC_EXT']
+        # When generating any code, there is no reason so use the old name
+        self.enumAliasMap = dict()
+        self.enumFieldAliasMap = dict()
+        self.bitmaskAliasMap = dict()
+        self.flagAliasMap = dict()
+        self.structAliasMap = dict()
+        self.handleAliasMap = dict()
+
+    def write(self, data):
+        # Prevents having to check before writing
+        if data is not None and data != "":
+            write(data, file=self.outFile)
+
+
+    def beginFile(self, genOpts):
+        OutputGenerator.beginFile(self, genOpts)
+        self.filename = genOpts.filename
+
+        # No gen*() command to get these, so do it manually
+        for platform in self.registry.tree.findall('platforms/platform'):
+            self.vk.platforms[platform.get('name')] = platform.get('protect')
+
+        for tags in self.registry.tree.findall('tags'):
+            for tag in tags.findall('tag'):
+                self.vk.vendorTags.append(tag.get('name'))
+
+        # No way known to get this from the XML
+        self.vk.queueBits[Queues.TRANSFER]       = 'VK_QUEUE_TRANSFER_BIT'
+        self.vk.queueBits[Queues.GRAPHICS]       = 'VK_QUEUE_GRAPHICS_BIT'
+        self.vk.queueBits[Queues.COMPUTE]        = 'VK_QUEUE_COMPUTE_BIT'
+        self.vk.queueBits[Queues.PROTECTED]      = 'VK_QUEUE_PROTECTED_BIT'
+        self.vk.queueBits[Queues.SPARSE_BINDING] = 'VK_QUEUE_SPARSE_BINDING_BIT'
+        self.vk.queueBits[Queues.OPTICAL_FLOW]   = 'VK_QUEUE_OPTICAL_FLOW_BIT_NV'
+        self.vk.queueBits[Queues.DECODE]         = 'VK_QUEUE_VIDEO_DECODE_BIT_KHR'
+        self.vk.queueBits[Queues.ENCODE]         = 'VK_QUEUE_VIDEO_ENCODE_BIT_KHR'
+
+    # This function should be overloaded
+    def generate(self):
+        print("WARNING: This should not be called from the child class")
+        return
+
+    # This function is dense, it does all the magic to set the right extensions dependencies!
+    #
+    # The issue is if 2 extension expose a command, genCmd() will only
+    # show one of the extension, at endFile() we can finally go through
+    # and update which things depend on which extensions
+    #
+    # self.featureDictionary is built for use in the reg.py framework
+    # Details found in Vulkan-Docs/scripts/scriptgenerator.py
+    def applyExtensionDependency(self):
+        for extension in self.vk.extensions.values():
+            # dict.key() can be None, so need to double loop
+            dict = self.featureDictionary[extension.name]['command']
+
+            # "required" == None
+            #         or
+            #  an additional feature dependency, which is a boolean expression of
+            #  one or more extension and/or core version names
+            for required in dict:
+                for commandName in dict[required]:
+                    # Skip commands removed in the target API
+                    # This check is needed because parts of the base generator code bypass the
+                    # dependency resolution logic in the registry tooling and thus the generator
+                    # may attempt to generate code for commands which are not supported in the
+                    # target API variant, thus this check needs to happen even if any specific
+                    # target API variant may not specifically need it
+                    if not commandName in self.vk.commands:
+                        continue
+
+                    command = self.vk.commands[commandName]
+                    # Make sure list is unique
+                    command.extensions.extend([extension] if extension not in command.extensions else [])
+                    extension.commands.extend([command] if command not in extension.commands else [])
+
+            # While genGroup() will call twice with aliased value, it does not provide all the information we need
+            dict = self.featureDictionary[extension.name]['enumconstant']
+            for required in dict:
+                # group can be a Enum or Bitmask
+                for group in dict[required]:
+                    if group in self.vk.enums:
+                        if group not in extension.enumFields:
+                            extension.enumFields[group] = [] # Dict needs init
+                        enum = self.vk.enums[group]
+                        # Need to convert all alias so they match what is in EnumField
+                        enumList = list(map(lambda x: x if x not in self.enumFieldAliasMap else self.enumFieldAliasMap[x], dict[required][group]))
+
+                        for enumField in [x for x in enum.fields if x.name in enumList]:
+                            # Make sure list is unique
+                            enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else [])
+                            enumField.extensions.extend([extension] if extension not in enumField.extensions else [])
+                            extension.enumFields[group].extend([enumField] if enumField not in extension.enumFields[group] else [])
+                    if group in self.vk.bitmasks:
+                        if group not in extension.flags:
+                            extension.flags[group] = [] # Dict needs init
+                        bitmask = self.vk.bitmasks[group]
+                        # Need to convert all alias so they match what is in Flags
+                        flagList = list(map(lambda x: x if x not in self.flagAliasMap else self.flagAliasMap[x], dict[required][group]))
+
+                        for flags in [x for x in bitmask.flags if x.name in flagList]:
+                            # Make sure list is unique
+                            bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else [])
+                            flags.extensions.extend([extension] if extension not in flags.extensions else [])
+                            extension.flags[group].extend([flags] if flags not in extension.flags[group] else [])
+
+        # Need to do 'enum'/'bitmask' after 'enumconstant' has applied everything so we can add implicit extensions
+        #
+        # Sometimes two extensions enable an Enum, but the newer extension version has extra flags allowed
+        # This information seems to be implicit, so need to update it here
+        # Go through each Flag and append the Enum extension to it
+        #
+        # ex. VkAccelerationStructureTypeKHR where GENERIC_KHR is not allowed with just VK_NV_ray_tracing
+        # This only works because the values are aliased as well, making the KHR a superset enum
+        for extension in self.vk.extensions.values():
+            dict = self.featureDictionary[extension.name]['enum']
+            for required in dict:
+                for group in dict[required]:
+                    for enumName in dict[required][group]:
+                        isAlias = enumName in self.enumAliasMap
+                        enumName = self.enumAliasMap[enumName] if isAlias else enumName
+                        if enumName in self.vk.enums:
+                            enum = self.vk.enums[enumName]
+                            enum.extensions.extend([extension] if extension not in enum.extensions else [])
+                            extension.enums.extend([enum] if enum not in extension.enums else [])
+                            # Update fields with implicit base extension
+                            if isAlias:
+                                continue
+                            enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else [])
+                            for enumField in [x for x in enum.fields if (not x.extensions or (x.extensions and all(e in enum.extensions for e in x.extensions)))]:
+                                enumField.extensions.extend([extension] if extension not in enumField.extensions else [])
+                                if enumName not in extension.enumFields:
+                                    extension.enumFields[enumName] = [] # Dict needs init
+                                extension.enumFields[enumName].extend([enumField] if enumField not in extension.enumFields[enumName] else [])
+
+            dict = self.featureDictionary[extension.name]['bitmask']
+            for required in dict:
+                for group in dict[required]:
+                    for bitmaskName in dict[required][group]:
+                        bitmaskName = bitmaskName.replace('Flags', 'FlagBits') # Works since Flags is not repeated in name
+                        isAlias = bitmaskName in self.bitmaskAliasMap
+                        bitmaskName = self.bitmaskAliasMap[bitmaskName] if isAlias else bitmaskName
+                        if bitmaskName in self.vk.bitmasks:
+                            bitmask = self.vk.bitmasks[bitmaskName]
+                            bitmask.extensions.extend([extension] if extension not in bitmask.extensions else [])
+                            extension.bitmasks.extend([bitmask] if bitmask not in extension.bitmasks else [])
+                            # Update flags with implicit base extension
+                            if isAlias:
+                                continue
+                            bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else [])
+                            for flag in [x for x in bitmask.flags if (not x.extensions or (x.extensions and all(e in bitmask.extensions for e in x.extensions)))]:
+                                flag.extensions.extend([extension] if extension not in flag.extensions else [])
+                                if bitmaskName not in extension.flags:
+                                    extension.flags[bitmaskName] = [] # Dict needs init
+                                extension.flags[bitmaskName].extend([flag] if flag not in extension.flags[bitmaskName] else [])
+
+        # Some structs (ex VkAttachmentSampleCountInfoAMD) can have multiple alias pointing to same extension
+        for extension in self.vk.extensions.values():
+            dict = self.featureDictionary[extension.name]['struct']
+            for required in dict:
+                for group in dict[required]:
+                    for structName in dict[required][group]:
+                        isAlias = structName in self.structAliasMap
+                        structName = self.structAliasMap[structName] if isAlias else structName
+                        # An EXT struct can alias a KHR struct,
+                        # that in turns aliaes a core struct
+                        # => Try to propagate aliasing, it can safely result in a no-op
+                        isAlias = structName in self.structAliasMap
+                        structName = self.structAliasMap[structName] if isAlias else structName
+                        if structName in self.vk.structs:
+                            struct = self.vk.structs[structName]
+                            struct.extensions.extend([extension] if extension not in struct.extensions else [])
+
+        # While we update struct alias inside other structs, the command itself might have the struct as a first level param.
+        # We use this time to update params to have the promoted name
+        # Example - https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/9322
+        for command in self.vk.commands.values():
+            for member in command.params:
+                if member.type in self.structAliasMap:
+                    member.type = self.structAliasMap[member.type]
+
+        # Could build up a reverse lookup map, but since these are not too large of list, just do here
+        # (Need to be done after we have found all the aliases)
+        for key, value in self.structAliasMap.items():
+            self.vk.structs[value].aliases.append(key)
+        for key, value in self.enumAliasMap.items():
+            self.vk.enums[value].aliases.append(key)
+        for key, value in self.bitmaskAliasMap.items():
+            self.vk.bitmasks[value].aliases.append(key)
+        for key, value in self.handleAliasMap.items():
+            self.vk.handles[value].aliases.append(key)
+
+    def endFile(self):
+        # This is the point were reg.py has ran, everything is collected
+        # We do some post processing now
+        self.applyExtensionDependency()
+
+        # Use structs and commands to find which things are returnedOnly
+        for struct in [x for x in self.vk.structs.values() if not x.returnedOnly]:
+            for enum in [self.vk.enums[x.type] for x in struct.members if x.type in self.vk.enums]:
+                enum.returnedOnly = False
+            for bitmask in [self.vk.bitmasks[x.type] for x in struct.members if x.type in self.vk.bitmasks]:
+                bitmask.returnedOnly = False
+            for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in struct.members if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]:
+                bitmask.returnedOnly = False
+        for command in self.vk.commands.values():
+            for enum in [self.vk.enums[x.type] for x in command.params if x.type in self.vk.enums]:
+                enum.returnedOnly = False
+            for bitmask in [self.vk.bitmasks[x.type] for x in command.params if x.type in self.vk.bitmasks]:
+                bitmask.returnedOnly = False
+            for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in command.params if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]:
+                bitmask.returnedOnly = False
+
+        # Turn handle parents into pointers to classes
+        for handle in [x for x in self.vk.handles.values() if x.parent is not None]:
+            handle.parent = self.vk.handles[handle.parent]
+        # search up parent chain to see if instance or device
+        for handle in [x for x in self.vk.handles.values()]:
+            next_parent = handle.parent
+            while (not handle.instance and not handle.device):
+                handle.instance = next_parent.name == 'VkInstance'
+                handle.device = next_parent.name == 'VkDevice'
+                next_parent = next_parent.parent
+
+        maxSyncSupport.queues = Queues.ALL
+        maxSyncSupport.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
+        maxSyncEquivalent.accesses = self.vk.bitmasks['VkAccessFlagBits2'].flags
+        maxSyncEquivalent.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
+
+        # All inherited generators should run from here
+        self.generate()
+
+        if cachingEnabled:
+            cachePath = os.path.join(tempfile.gettempdir(), f'vkobject_{os.getpid()}')
+            if not os.path.isfile(cachePath):
+                cacheFile = open(cachePath, 'wb')
+                pickle.dump(self.vk, cacheFile)
+                cacheFile.close()
+
+        # This should not have to do anything but call into OutputGenerator
+        OutputGenerator.endFile(self)
+
+    #
+    # Bypass the entire processing and load in the VkObject data
+    # Still need to handle the beingFile/endFile for reg.py
+    def generateFromCache(self, cacheVkObjectData, genOpts):
+        OutputGenerator.beginFile(self, genOpts)
+        self.filename = genOpts.filename
+        self.vk = cacheVkObjectData
+        self.generate()
+        OutputGenerator.endFile(self)
+
+    #
+    # Processing point at beginning of each extension definition
+    def beginFeature(self, interface, emit):
+        OutputGenerator.beginFeature(self, interface, emit)
+        platform = interface.get('platform')
+        self.featureExtraProtec = self.vk.platforms[platform] if platform in self.vk.platforms else None
+        protect = self.vk.platforms[platform] if platform in self.vk.platforms else None
+        name = interface.get('name')
+
+        if interface.tag == 'extension':
+            instance = interface.get('type') == 'instance'
+            device = not instance
+            depends = interface.get('depends')
+            vendorTag = interface.get('author')
+            platform = interface.get('platform')
+            provisional = boolGet(interface, 'provisional')
+            promotedto = interface.get('promotedto')
+            deprecatedby = interface.get('deprecatedby')
+            obsoletedby = interface.get('obsoletedby')
+            specialuse = splitIfGet(interface, 'specialuse')
+            # Not sure if better way to get this info
+            specVersion = self.featureDictionary[name]['enumconstant'][None][None][0]
+            nameString = self.featureDictionary[name]['enumconstant'][None][None][1]
+
+            self.currentExtension = Extension(name, nameString, specVersion, instance, device, depends, vendorTag,
+                                            platform, protect, provisional, promotedto, deprecatedby,
+                                            obsoletedby, specialuse)
+            self.vk.extensions[name] = self.currentExtension
+        else: # version
+            number = interface.get('number')
+            if number != '1.0':
+                self.currentVersion = APISpecific.createApiVersion(self.targetApiName, name)
+                self.vk.versions[name] = self.currentVersion
+
+    def endFeature(self):
+        OutputGenerator.endFeature(self)
+        self.currentExtension = None
+        self.currentVersion = None
+
+    #
+    # All <command> from XML
+    def genCmd(self, cmdinfo, name, alias):
+        OutputGenerator.genCmd(self, cmdinfo, name, alias)
+
+        params = []
+        for param in cmdinfo.elem.findall('param'):
+            paramName = param.find('name').text
+            paramType = textIfFind(param, 'type')
+            paramAlias = param.get('alias')
+
+            cdecl = self.makeCParamDecl(param, 0)
+            paramFullType = ' '.join(cdecl.split()[:-1])
+            pointer = '*' in cdecl or paramType.startswith('PFN_')
+            paramConst = 'const' in cdecl
+            fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')]
+
+            paramNoautovalidity = boolGet(param, 'noautovalidity')
+
+            nullTerminated = False
+            length = param.get('altlen') if param.get('altlen') is not None else param.get('len')
+            if length:
+                # we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated"
+                # This finds both
+                nullTerminated = 'null-terminated' in length
+                length = length.replace(',null-terminated', '') if 'null-terminated' in length else length
+                length = None if length == 'null-terminated' else length
+
+            if fixedSizeArray and not length:
+                length = ','.join(fixedSizeArray)
+
+            # See Member::optional code for details of this
+            optionalValues = splitIfGet(param, 'optional')
+            optional = optionalValues is not None and optionalValues[0].lower() == "true"
+            optionalPointer = optionalValues is not None and len(optionalValues) > 1 and optionalValues[1].lower() == "true"
+
+            # externsync will be 'true' or expression
+            # if expression, it should be same as 'true'
+            externSync = boolGet(param, 'externsync')
+            externSyncPointer = None if externSync else splitIfGet(param, 'externsync')
+            if not externSync and externSyncPointer is not None:
+                externSync = True
+
+            params.append(Param(paramName, paramAlias, paramType, paramFullType, paramNoautovalidity,
+                                paramConst, length, nullTerminated, pointer, fixedSizeArray,
+                                optional, optionalPointer,
+                                externSync, externSyncPointer, cdecl))
+
+        attrib = cmdinfo.elem.attrib
+        alias = attrib.get('alias')
+        tasks = splitIfGet(attrib, 'tasks')
+
+        queues = getQueues(attrib)
+        successcodes = splitIfGet(attrib, 'successcodes')
+        errorcodes = splitIfGet(attrib, 'errorcodes')
+        cmdbufferlevel = attrib.get('cmdbufferlevel')
+        primary = cmdbufferlevel is not None and 'primary' in cmdbufferlevel
+        secondary = cmdbufferlevel is not None and 'secondary' in cmdbufferlevel
+
+        renderpass = attrib.get('renderpass')
+        renderpass = CommandScope.NONE if renderpass is None else getattr(CommandScope, renderpass.upper())
+        videocoding = attrib.get('videocoding')
+        videocoding = CommandScope.NONE if videocoding is None else getattr(CommandScope, videocoding.upper())
+
+        protoElem = cmdinfo.elem.find('proto')
+        returnType = textIfFind(protoElem, 'type')
+
+        decls = self.makeCDecls(cmdinfo.elem)
+        cPrototype = decls[0]
+        cFunctionPointer = decls[1]
+
+        protect = self.currentExtension.protect if self.currentExtension is not None else None
+
+        # These coammds have no way from the XML to detect they would be an instance command
+        specialInstanceCommand = ['vkCreateInstance', 'vkEnumerateInstanceExtensionProperties','vkEnumerateInstanceLayerProperties', 'vkEnumerateInstanceVersion']
+        instance = len(params) > 0 and (params[0].type == 'VkInstance' or params[0].type == 'VkPhysicalDevice' or name in specialInstanceCommand)
+        device = not instance
+
+        implicitElem = cmdinfo.elem.find('implicitexternsyncparams')
+        implicitExternSyncParams = [x.text for x in implicitElem.findall('param')] if implicitElem else []
+
+        self.vk.commands[name] = Command(name, alias, protect, [], self.currentVersion,
+                                         returnType, params, instance, device,
+                                         tasks, queues, successcodes, errorcodes,
+                                         primary, secondary, renderpass, videocoding,
+                                         implicitExternSyncParams, cPrototype, cFunctionPointer)
+
+    #
+    # List the enum for the commands
+    # TODO - Seems empty groups like `VkDeviceDeviceMemoryReportCreateInfoEXT` do not show up in here
+    def genGroup(self, groupinfo, groupName, alias):
+        # There can be case where the Enum/Bitmask is in a protect, but the individual
+        # fields also have their own protect
+        groupProtect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None
+        enumElem = groupinfo.elem
+        bitwidth = 32 if enumElem.get('bitwidth') is None else int(enumElem.get('bitwidth'))
+        fields = []
+        if enumElem.get('type') == "enum":
+            if alias is not None:
+                self.enumAliasMap[groupName] = alias
+                return
+
+            for elem in enumElem.findall('enum'):
+                fieldName = elem.get('name')
+
+                if elem.get('alias') is not None:
+                    self.enumFieldAliasMap[fieldName] = elem.get('alias')
+                    continue
+
+                negative = elem.get('dir') is not None
+                protect = elem.get('protect')
+                (valueInt, valueStr) = self.enumToValue(elem, True, bitwidth)
+
+                # Some values have multiple extensions (ex VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
+                # genGroup() lists them twice
+                if next((x for x in fields if x.name == fieldName), None) is None:
+                    fields.append(EnumField(fieldName, protect, negative, valueInt, valueStr, []))
+
+            self.vk.enums[groupName] = Enum(groupName, [], groupProtect, bitwidth, True, fields, [], [])
+
+        else: # "bitmask"
+            if alias is not None:
+                self.bitmaskAliasMap[groupName] = alias
+                return
+
+            for elem in enumElem.findall('enum'):
+                flagName = elem.get('name')
+
+                if elem.get('alias') is not None:
+                    self.flagAliasMap[flagName] = elem.get('alias')
+                    continue
+
+                protect = elem.get('protect')
+
+                (valueInt, valueStr) = self.enumToValue(elem, True, bitwidth)
+                flagZero = valueInt == 0
+                flagMultiBit = False
+                # if flag uses 'value' instead of 'bitpos', will be zero or a mask
+                if elem.get('bitpos') is None and elem.get('value'):
+                    flagMultiBit = valueInt != 0
+
+                # Some values have multiple extensions (ex VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
+                # genGroup() lists them twice
+                if next((x for x in fields if x.name == flagName), None) is None:
+                    fields.append(Flag(flagName, protect, valueInt, valueStr, flagMultiBit, flagZero, []))
+
+            flagName = groupName.replace('FlagBits', 'Flags')
+            self.vk.bitmasks[groupName] = Bitmask(groupName, [], flagName, groupProtect, bitwidth, True, fields, [], [])
+
+    def genType(self, typeInfo, typeName, alias):
+        OutputGenerator.genType(self, typeInfo, typeName, alias)
+        typeElem = typeInfo.elem
+        protect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None
+        category = typeElem.get('category')
+        if (category == 'struct' or category == 'union'):
+            extension = [self.currentExtension] if self.currentExtension is not None else []
+            if alias is not None:
+                self.structAliasMap[typeName] = alias
+                return
+
+            union = category == 'union'
+
+            returnedOnly = boolGet(typeElem, 'returnedonly')
+            allowDuplicate = boolGet(typeElem, 'allowduplicate')
+
+            extends = splitIfGet(typeElem, 'structextends')
+            extendedBy = self.registry.validextensionstructs[typeName] if len(self.registry.validextensionstructs[typeName]) > 0 else None
+
+            membersElem = typeInfo.elem.findall('.//member')
+            members = []
+            sType = None
+
+            for member in membersElem:
+                for comment in member.findall('comment'):
+                    member.remove(comment)
+
+                name = textIfFind(member, 'name')
+                type = textIfFind(member, 'type')
+                sType = member.get('values') if member.get('values') is not None else sType
+                externSync = boolGet(member, 'externsync')
+                noautovalidity = boolGet(member, 'noautovalidity')
+                limittype = member.get('limittype')
+
+                nullTerminated = False
+                length = member.get('altlen') if member.get('altlen') is not None else member.get('len')
+                if length:
+                    # we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated"
+                    # This finds both
+                    nullTerminated = 'null-terminated' in length
+                    length = length.replace(',null-terminated', '') if 'null-terminated' in length else length
+                    length = None if length == 'null-terminated' else length
+
+                cdecl = self.makeCParamDecl(member, 0)
+                fullType = ' '.join(cdecl.split()[:-1])
+                pointer = '*' in cdecl or type.startswith('PFN_')
+                const = 'const' in cdecl
+                # Some structs like VkTransformMatrixKHR have a 2D array
+                fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')]
+
+                if fixedSizeArray and not length:
+                    length = ','.join(fixedSizeArray)
+
+                # if a pointer, this can be a something like:
+                #     optional="true,false" for ppGeometries
+                #     optional="false,true" for pPhysicalDeviceCount
+                # the first is if the variable itself is optional
+                # the second is the value of the pointer is optional;
+                optionalValues = splitIfGet(member, 'optional')
+                optional = optionalValues is not None and optionalValues[0].lower() == "true"
+                optionalPointer = optionalValues is not None and len(optionalValues) > 1 and optionalValues[1].lower() == "true"
+
+                members.append(Member(name, type, fullType, noautovalidity, limittype,
+                                      const, length, nullTerminated, pointer, fixedSizeArray,
+                                      optional, optionalPointer,
+                                      externSync, cdecl))
+
+            self.vk.structs[typeName] = Struct(typeName, [], extension, self.currentVersion, protect, members,
+                                               union, returnedOnly, sType, allowDuplicate, extends, extendedBy)
+
+        elif category == 'handle':
+            if alias is not None:
+                self.handleAliasMap[typeName] = alias
+                return
+            type = typeElem.get('objtypeenum')
+
+            # will resolve these later, the VulkanObjectType does not list things in dependent order
+            parent = typeElem.get('parent')
+            instance = typeName == 'VkInstance'
+            device = typeName == 'VkDevice'
+
+            dispatchable = typeElem.find('type').text == 'VK_DEFINE_HANDLE'
+
+            self.vk.handles[typeName] = Handle(typeName, [], type, protect, parent, instance, device, dispatchable)
+
+        elif category == 'define':
+            if typeName == 'VK_HEADER_VERSION':
+                self.vk.headerVersion = typeElem.find('name').tail.strip()
+
+        else:
+            # not all categories are used
+            #   'group'/'enum'/'bitmask' are routed to genGroup instead
+            #   'basetype'/'include' are only for headers
+            #   'funcpointer` ignore until needed
+            return
+
+    def genSpirv(self, spirvinfo, spirvName, alias):
+        OutputGenerator.genSpirv(self, spirvinfo, spirvName, alias)
+        spirvElem = spirvinfo.elem
+        name = spirvElem.get('name')
+        extension = True if spirvElem.tag == 'spirvextension' else False
+        capability = not extension
+
+        enables = []
+        for elem in spirvElem:
+            version = elem.attrib.get('version')
+            extensionEnable = elem.attrib.get('extension')
+            struct = elem.attrib.get('struct')
+            feature = elem.attrib.get('feature')
+            requires = elem.attrib.get('requires')
+            propertyEnable = elem.attrib.get('property')
+            member = elem.attrib.get('member')
+            value = elem.attrib.get('value')
+            enables.append(SpirvEnables(version, extensionEnable, struct, feature,
+                                        requires, propertyEnable, member, value))
+
+        self.vk.spirv.append(Spirv(name, extension, capability, enables))
+
+    def genFormat(self, format, formatinfo, alias):
+        OutputGenerator.genFormat(self, format, formatinfo, alias)
+        formatElem = format.elem
+        name = formatElem.get('name')
+
+        components = []
+        for component in formatElem.iterfind('component'):
+            type = component.get('name')
+            bits = component.get('bits')
+            numericFormat = component.get('numericFormat')
+            planeIndex = intIfGet(component, 'planeIndex')
+            components.append(FormatComponent(type, bits, numericFormat, planeIndex))
+
+        planes = []
+        for plane in formatElem.iterfind('plane'):
+            index = int(plane.get('index'))
+            widthDivisor = int(plane.get('widthDivisor'))
+            heightDivisor = int(plane.get('heightDivisor'))
+            compatible = plane.get('compatible')
+            planes.append(FormatPlane(index, widthDivisor, heightDivisor, compatible))
+
+        className = formatElem.get('class')
+        blockSize = int(formatElem.get('blockSize'))
+        texelsPerBlock = int(formatElem.get('texelsPerBlock'))
+        blockExtent = splitIfGet(formatElem, 'blockExtent')
+        packed = intIfGet(formatElem, 'packed')
+        chroma = formatElem.get('chroma')
+        compressed = formatElem.get('compressed')
+        spirvImageFormat = formatElem.find('spirvimageformat')
+        if spirvImageFormat is not None:
+            spirvImageFormat = spirvImageFormat.get('name')
+
+        self.vk.formats[name] = Format(name, className, blockSize, texelsPerBlock,
+                                       blockExtent, packed, chroma, compressed,
+                                       components, planes, spirvImageFormat)
+
+    def genSyncStage(self, sync):
+        OutputGenerator.genSyncStage(self, sync)
+        syncElem = sync.elem
+
+        support = maxSyncSupport
+        supportElem = syncElem.find('syncsupport')
+        if supportElem is not None:
+            queues = getQueues(supportElem)
+            stageNames = splitIfGet(supportElem, 'stage')
+            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
+            support = SyncSupport(queues, stages, False)
+
+        equivalent = maxSyncEquivalent
+        equivalentElem = syncElem.find('syncequivalent')
+        if equivalentElem is not None:
+            stageNames = splitIfGet(equivalentElem, 'stage')
+            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
+            accessNames = splitIfGet(equivalentElem, 'access')
+            accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if accessNames is not None else None
+            equivalent = SyncEquivalent(stages, accesses, False)
+
+        flagName = syncElem.get('name')
+        flag = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name == flagName]
+        # This check is needed because not all API variants have VK_KHR_synchronization2
+        if flag:
+            self.vk.syncStage.append(SyncStage(flag[0], support, equivalent))
+
+    def genSyncAccess(self, sync):
+        OutputGenerator.genSyncAccess(self, sync)
+        syncElem = sync.elem
+
+        support = maxSyncSupport
+        supportElem = syncElem.find('syncsupport')
+        if supportElem is not None:
+            queues = getQueues(supportElem)
+            stageNames = splitIfGet(supportElem, 'stage')
+            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
+            support = SyncSupport(queues, stages, False)
+
+        equivalent = maxSyncEquivalent
+        equivalentElem = syncElem.find('syncequivalent')
+        if equivalentElem is not None:
+            stageNames = splitIfGet(equivalentElem, 'stage')
+            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
+            accessNames = splitIfGet(equivalentElem, 'access')
+            accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if accessNames is not None else None
+            equivalent = SyncEquivalent(stages, accesses, False)
+
+        flagName = syncElem.get('name')
+        flag = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name == flagName]
+        # This check is needed because not all API variants have VK_KHR_synchronization2
+        if flag:
+            self.vk.syncAccess.append(SyncAccess(flag[0], support, equivalent))
+
+    def genSyncPipeline(self, sync):
+        OutputGenerator.genSyncPipeline(self, sync)
+        syncElem = sync.elem
+        name = syncElem.get('name')
+        depends = splitIfGet(syncElem, 'depends')
+        stages = []
+        for stageElem in syncElem.findall('syncpipelinestage'):
+            order = stageElem.get('order')
+            before = stageElem.get('before')
+            after = stageElem.get('after')
+            value = stageElem.text
+            stages.append(SyncPipelineStage(order, before, after, value))
+
+        self.vk.syncPipeline.append(SyncPipeline(name, depends, stages))
--- a/registry/cgenerator.py
+++ b/registry/cgenerator.py
@ -242,7 +242,7 @@ class COutputGenerator(OutputGenerator):
                    raise MissingGeneratorOptionsError()
                if self.genOpts.conventions is None:
                    raise MissingGeneratorOptionsConventionsError()
-                is_core = self.featureName and self.featureName.startswith(self.conventions.api_prefix + 'VERSION_')
+                is_core = self.featureName and self.featureName.startswith(f"{self.conventions.api_prefix}VERSION_")
                if self.genOpts.conventions.writeFeature(self.featureName, self.featureExtraProtect, self.genOpts.filename):
                    self.newline()
                    if self.genOpts.protectFeature:
@ -340,7 +340,7 @@ class COutputGenerator(OutputGenerator):
            # OpenXR: this section was not under 'else:' previously, just fell through
            if alias:
                # If the type is an alias, just emit a typedef declaration
-                body += 'typedef ' + alias + ' ' + name + ';\n'
+                body += f"typedef {alias} {name};\n"
            else:
                # Replace <apientry /> tags with an APIENTRY-style string
                # (from self.genOpts). Copy other text through unchanged.
@ -373,13 +373,13 @@ class COutputGenerator(OutputGenerator):

        if ',' in protect_str:
            protect_list = protect_str.split(',')
-            protect_defs = ('defined(%s)' % d for d in protect_list)
+            protect_defs = (f'defined({d})' for d in protect_list)
            protect_def_str = ' && '.join(protect_defs)
-            protect_if_str = '#if %s\n' % protect_def_str
-            protect_end_str = '#endif // %s\n' % protect_def_str
+            protect_if_str = f'#if {protect_def_str}\n'
+            protect_end_str = f'#endif // {protect_def_str}\n'
        else:
-            protect_if_str = '#ifdef %s\n' % protect_str
-            protect_end_str = '#endif // %s\n' % protect_str
+            protect_if_str = f'#ifdef {protect_str}\n'
+            protect_end_str = f'#endif // {protect_str}\n'

        return (protect_if_str, protect_end_str)

@ -423,7 +423,7 @@ class COutputGenerator(OutputGenerator):
        body = self.deprecationComment(typeElem)

        if alias:
-            body += 'typedef ' + alias + ' ' + typeName + ';\n'
+            body += f"typedef {alias} {typeName};\n"
        else:
            (protect_begin, protect_end) = self.genProtectString(typeElem.get('protect'))
            if protect_begin:
@ -431,24 +431,24 @@ class COutputGenerator(OutputGenerator):

            if self.genOpts.genStructExtendsComment:
                structextends = typeElem.get('structextends')
-                body += '// ' + typeName + ' extends ' + structextends + '\n' if structextends else ''
+                body += f"// {typeName} extends {structextends}\n" if structextends else ''

-            body += 'typedef ' + typeElem.get('category')
+            body += f"typedef {typeElem.get('category')}"

            # This is an OpenXR-specific alternative where aliasing refers
            # to an inheritance hierarchy of types rather than C-level type
            # aliases.
            if self.genOpts.genAliasMacro and self.typeMayAlias(typeName):
-                body += ' ' + self.genOpts.aliasMacro
+                body += f" {self.genOpts.aliasMacro}"

-            body += ' ' + typeName + ' {\n'
+            body += f" {typeName} {{\n"

            targetLen = self.getMaxCParamTypeLength(typeinfo)
            for member in typeElem.findall('.//member'):
                body += self.deprecationComment(member, indent = 4)
                body += self.makeCParamDecl(member, targetLen + 4)
                body += ';\n'
-            body += '} ' + typeName + ';\n'
+            body += f"}} {typeName};\n"
            if protect_end:
                body += protect_end

@ -474,13 +474,13 @@ class COutputGenerator(OutputGenerator):
        if alias:
            # If the group name is aliased, just emit a typedef declaration
            # for the alias.
-            body = 'typedef ' + alias + ' ' + groupName + ';\n'
+            body = f"typedef {alias} {groupName};\n"
            self.appendSection(section, body)
        else:
            if self.genOpts is None:
                raise MissingGeneratorOptionsError()
            (section, body) = self.buildEnumCDecl(self.genOpts.genEnumBeginEndRange, groupinfo, groupName)
-            self.appendSection(section, '\n' + body)
+            self.appendSection(section, f"\n{body}")

    def genEnum(self, enuminfo, name, alias):
        """Generate the C declaration for a constant (a single <enum> value).
@ -507,7 +507,7 @@ class COutputGenerator(OutputGenerator):

        prefix = ''
        decls = self.makeCDecls(cmdinfo.elem)
-        self.appendSection('command', prefix + decls[0] + '\n')
+        self.appendSection('command', f"{prefix + decls[0]}\n")
        if self.genOpts.genFuncPointers:
            self.appendSection('commandPointer', decls[1])

--- a/registry/generator.py
+++ b/registry/generator.py
@ -116,7 +116,7 @@ class MissingGeneratorOptionsError(RuntimeError):
    def __init__(self, msg=None):
        full_msg = 'Missing generator options object self.genOpts'
        if msg:
-            full_msg += ': ' + msg
+            full_msg += f": {msg}"
        super().__init__(full_msg)


@ -126,7 +126,7 @@ class MissingRegistryError(RuntimeError):
    def __init__(self, msg=None):
        full_msg = 'Missing Registry object self.registry'
        if msg:
-            full_msg += ': ' + msg
+            full_msg += f": {msg}"
        super().__init__(full_msg)


@ -136,7 +136,7 @@ class MissingGeneratorOptionsConventionsError(RuntimeError):
    def __init__(self, msg=None):
        full_msg = 'Missing Conventions object self.genOpts.conventions'
        if msg:
-            full_msg += ': ' + msg
+            full_msg += f": {msg}"
        super().__init__(full_msg)


@ -338,7 +338,7 @@ class OutputGenerator:
        )

        if name in bad and True:
-            print('breakName {}: {}'.format(name, msg))
+            print(f'breakName {name}: {msg}')
            pdb.set_trace()

    def __init__(self, errFile=sys.stderr, warnFile=sys.stderr, diagFile=sys.stdout):
@ -399,7 +399,7 @@ class OutputGenerator:
                write('DIAG:', *args, file=self.diagFile)
        else:
            raise UserWarning(
-                '*** FATAL ERROR in Generator.logMsg: unknown level:' + level)
+                f"*** FATAL ERROR in Generator.logMsg: unknown level:{level}")

    def enumToValue(self, elem, needsNum, bitwidth = 32,
                    forceSuffix = False, parent_for_alias_dereference=None):
@ -452,20 +452,20 @@ class OutputGenerator:
            #     value += enuminfo.type
            if forceSuffix:
              if bitwidth == 64:
-                value = value + 'ULL'
+                value = f"{value}ULL"
              else:
-                value = value + 'U'
+                value = f"{value}U"
            self.logMsg('diag', 'Enum', name, '-> value [', numVal, ',', value, ']')
            return [numVal, value]
        if 'bitpos' in elem.keys():
            value = elem.get('bitpos')
            bitpos = int(value, 0)
            numVal = 1 << bitpos
-            value = '0x%08x' % numVal
+            value = f'0x{numVal:08x}'
            if bitwidth == 64 or bitpos >= 32:
-              value = value + 'ULL'
+              value = f"{value}ULL"
            elif forceSuffix:
-              value = value + 'U'
+              value = f"{value}U"
            self.logMsg('diag', 'Enum', name, '-> bitpos [', numVal, ',', value, ']')
            return [numVal, value]
        if 'offset' in elem.keys():
@ -655,12 +655,12 @@ class OutputGenerator:
        flagTypeName = groupElem.get('name')

        # Prefix
-        body = "// Flag bits for " + flagTypeName + "\n"
+        body = f"// Flag bits for {flagTypeName}\n"

        if bitwidth == 64:
-            body += "typedef VkFlags64 %s;\n" % flagTypeName;
+            body += f"typedef VkFlags64 {flagTypeName};\n";
        else:
-            body += "typedef VkFlags %s;\n" % flagTypeName;
+            body += f"typedef VkFlags {flagTypeName};\n";

        # Maximum allowable value for a flag (unsigned 64-bit integer)
        maxValidValue = 2**(64) - 1
@ -697,25 +697,25 @@ class OutputGenerator:
            if self.isEnumRequired(elem):
                protect = elem.get('protect')
                if protect is not None:
-                    body += '#ifdef {}\n'.format(protect)
+                    body += f'#ifdef {protect}\n'

                body += self.deprecationComment(elem, indent = 0)

                if usedefine:
-                    decl += "#define {} {}\n".format(name, strVal)
+                    decl += f"#define {name} {strVal}\n"
                elif self.misracppstyle():
-                    decl += "static constexpr {} {} {{{}}};\n".format(flagTypeName, name, strVal)
+                    decl += f"static constexpr {flagTypeName} {name} {{{strVal}}};\n"
                else:
                    # Some C compilers only allow initializing a 'static const' variable with a literal value.
                    # So initializing an alias from another 'static const' value would fail to compile.
                    # Work around this by chasing the aliases to get the actual value.
                    while numVal is None:
-                        alias = self.registry.tree.find("enums/enum[@name='" + strVal + "']")
+                        alias = self.registry.tree.find(f"enums/enum[@name='{strVal}']")
                        if alias is not None:
                            (numVal, strVal) = self.enumToValue(alias, True, bitwidth, True)
                        else:
-                            self.logMsg('error', 'No such alias {} for enum {}'.format(strVal, name))
-                    decl += "static const {} {} = {};\n".format(flagTypeName, name, strVal)
+                            self.logMsg('error', f'No such alias {strVal} for enum {name}')
+                    decl += f"static const {flagTypeName} {name} = {strVal};\n"

                if numVal is not None:
                    body += decl
@ -743,7 +743,7 @@ class OutputGenerator:
        expandSuffix = ''
        expandSuffixMatch = re.search(r'[A-Z][A-Z]+$', groupName)
        if expandSuffixMatch:
-            expandSuffix = '_' + expandSuffixMatch.group()
+            expandSuffix = f"_{expandSuffixMatch.group()}"
            # Strip off the suffix from the prefix
            expandPrefix = expandName.rsplit(expandSuffix, 1)[0]

@ -792,12 +792,12 @@ class OutputGenerator:

                protect = elem.get('protect')
                if protect is not None:
-                    decl += '#ifdef {}\n'.format(protect)
+                    decl += f'#ifdef {protect}\n'


                decl += self.genRequirements(name, mustBeFound = False, indent = 2)
                decl += self.deprecationComment(elem, indent = 2)
-                decl += '    {} = {},'.format(name, strVal)
+                decl += f'    {name} = {strVal},'

                if protect is not None:
                    decl += '\n#endif'
@ -868,8 +868,8 @@ class OutputGenerator:
            if typeStr != "float":
                number += 'U'
            strVal = "~" if invert else ""
-            strVal += "static_cast<" + typeStr + ">(" + number + ")"
-            body = 'static constexpr ' + typeStr.ljust(9) + name.ljust(33) + ' {' + strVal + '};'
+            strVal += f"static_cast<{typeStr}>({number})"
+            body = f"static constexpr {typeStr.ljust(9)}{name.ljust(33)} {{{strVal}}};"
        elif enuminfo.elem.get('type') and not alias:
            # Generate e.g.: #define x (~0ULL)
            typeStr = enuminfo.elem.get('type');
@ -884,10 +884,10 @@ class OutputGenerator:
            strVal = "~" if invert else ""
            strVal += number
            if paren:
-                strVal = "(" + strVal + ")";
-            body = '#define ' + name.ljust(33) + ' ' + strVal;
+                strVal = f"({strVal})";
+            body = f"#define {name.ljust(33)} {strVal}";
        else:
-            body = '#define ' + name.ljust(33) + ' ' + strVal
+            body = f"#define {name.ljust(33)} {strVal}"

        return body

@ -1102,7 +1102,7 @@ class OutputGenerator:
        """Make the function-pointer typedef name for a command."""
        if self.genOpts is None:
            raise MissingGeneratorOptionsError()
-        return '(' + self.genOpts.apientryp + 'PFN_' + name + tail + ')'
+        return f"({self.genOpts.apientryp}PFN_{name}{tail})"

    def makeCParamDecl(self, param, aligncol):
        """Return a string which is an indented, formatted
@ -1135,14 +1135,14 @@ class OutputGenerator:
                # This works around a problem where very long type names -
                # longer than the alignment column - would run into the tail
                # text.
-                paramdecl = paramdecl.ljust(aligncol - 1) + ' '
+                paramdecl = f"{paramdecl.ljust(aligncol - 1)} "
                newLen = len(paramdecl)
                self.logMsg('diag', 'Adjust length of parameter decl from', oldLen, 'to', newLen, ':', paramdecl)

            if (self.misracppstyle() and prefix.find('const ') != -1):
                # Change pointer type order from e.g. "const void *" to "void const *".
                # If the string starts with 'const', reorder it to be after the first type.
-                paramdecl += prefix.replace('const ', '') + text + ' const' + tail
+                paramdecl += f"{prefix.replace('const ', '') + text} const{tail}"
            else:
                paramdecl += prefix + text + tail

@ -1169,7 +1169,7 @@ class OutputGenerator:

        # Allow for missing <name> tag
        newLen = 0
-        paramdecl = '    ' + noneStr(param.text)
+        paramdecl = f"    {noneStr(param.text)}"
        for elem in param:
            text = noneStr(elem.text)
            tail = noneStr(elem.tail)
@ -1400,7 +1400,7 @@ class OutputGenerator:
                            # Change pointer type order from e.g. "const void *" to "void const *".
                            # If the string starts with 'const', reorder it to be after the first type.
                            if (prefix.find('const ') != -1):
-                                param += prefix.replace('const ', '') + t + ' const '
+                                param += f"{prefix.replace('const ', '') + t} const "
                            else:
                                param += prefix + t
                            # Clear prefix for subsequent iterations
--- a/registry/parse_dependency.py
+++ b/registry/parse_dependency.py
@ -111,7 +111,7 @@ def push_first(toks):
    exprStack.append(toks[0])

 # An identifier (version, feature boolean, or extension name)
-dependencyIdent = Word(alphanums + '_' + ':')
+dependencyIdent = Word(f"{alphanums}_:")

 # Infix expression for depends expressions
 dependencyExpr = pp.infixNotation(dependencyIdent,
@ -288,7 +288,7 @@ def markupTraverse(expr, level = 0, root = True):
       - root - True only on initial call"""

    if level > 0:
-        prefix = '{nbsp}{nbsp}' * level * 2 + ' '
+        prefix = f"{'{nbsp}{nbsp}' * level * 2} "
    else:
        prefix = ''
    str = ''
@ -303,9 +303,9 @@ def markupTraverse(expr, level = 0, root = True):

            str = str + markupTraverse(elem, level = nextlevel, root = False)
        elif elem in ('+', ','):
-            str = str + f'{prefix}{opMarkupAsciidoc(elem)} +\n'
+            str = f"{str}{prefix}{opMarkupAsciidoc(elem)} +\n"
        else:
-            str = str + f'{prefix}{leafMarkupAsciidoc(elem)} +\n'
+            str = f"{str}{prefix}{leafMarkupAsciidoc(elem)} +\n"

    return str

--- a/registry/reg.py
+++ b/registry/reg.py
@ -801,7 +801,7 @@ class Registry:
                            if enum.get('alias'):
                                format_name = enum.get('alias')
                            if format_name in format_condition:
-                                format_condition[format_name] += "," + featureInfo.name
+                                format_condition[format_name] += f",{featureInfo.name}"
                            else:
                                format_condition[format_name] = featureInfo.name
                        elif groupName == "VkPipelineStageFlagBits2":
@ -810,7 +810,7 @@ class Registry:
                                stage_flag = enum.get('alias')
                            featureName = elem.get('depends') if elem.get('depends') is not None else featureInfo.name
                            if stage_flag in sync_pipeline_stage_condition:
-                                sync_pipeline_stage_condition[stage_flag] += "," + featureName
+                                sync_pipeline_stage_condition[stage_flag] += f",{featureName}"
                            else:
                                sync_pipeline_stage_condition[stage_flag] = featureName
                        elif groupName == "VkAccessFlagBits2":
@ -819,7 +819,7 @@ class Registry:
                                access_flag = enum.get('alias')
                            featureName = elem.get('depends') if elem.get('depends') is not None else featureInfo.name
                            if access_flag in sync_access_condition:
-                                sync_access_condition[access_flag] += "," + featureName
+                                sync_access_condition[access_flag] += f",{featureName}"
                            else:
                                sync_access_condition[access_flag] = featureName

@ -991,7 +991,7 @@ class Registry:
                    # Look up the Info with matching groupName
                    if groupName in self.groupdict:
                        gi = self.groupdict[groupName]
-                        gienum = gi.elem.find("enum[@name='" + enumname + "']")
+                        gienum = gi.elem.find(f"enum[@name='{enumname}']")
                        if gienum is not None:
                            # Remove copy of this enum from the group
                            gi.elem.remove(gienum)
@ -1207,7 +1207,7 @@ class Registry:
                                self.gen.featureDictionary[featurename][typecat][required_key][typeextends] = []
                            self.gen.featureDictionary[featurename][typecat][required_key][typeextends].append(typename)
                        else:
-                            self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
+                            self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')


                for enumElem in require.findall('enum'):
@ -1224,7 +1224,7 @@ class Registry:
                            self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends] = []
                        self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends].append(enumname)
                    else:
-                        self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
+                        self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')

                for cmdElem in require.findall('command'):
                    # Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible.
@ -1234,7 +1234,7 @@ class Registry:
                            self.gen.featureDictionary[featurename]['command'][required_key] = []
                        self.gen.featureDictionary[featurename]['command'][required_key].append(cmdElem.get('name'))
                    else:
-                        self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
+                        self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')

    def requireFeatures(self, interface, featurename, api, profile):
        """Process `<require>` tags for a `<version>` or `<extension>`.
--- a/registry/spec_tools/conventions.py
+++ b/registry/spec_tools/conventions.py
@ -52,7 +52,7 @@ class ProseListFormats(Enum):
            return cls.OR
        if s == 'and':
            return cls.AND
-        raise RuntimeError("Unrecognized string connective: " + s)
+        raise RuntimeError(f"Unrecognized string connective: {s}")

    @property
    def connective(self):
@ -96,11 +96,11 @@ class ConventionsBase(abc.ABC):

    def formatVersion(self, name, apivariant, major, minor):
        """Mark up an API version name as a link in the spec."""
-        return '`<<{}>>`'.format(name)
+        return f'`<<{name}>>`'

    def formatExtension(self, name):
        """Mark up an extension name as a link in the spec."""
-        return '`<<{}>>`'.format(name)
+        return f'`<<{name}>>`'

    def formatSPIRVlink(self, name):
        """Mark up a SPIR-V extension name as an external link in the spec.
@ -224,7 +224,7 @@ class ConventionsBase(abc.ABC):

        my_elts = list(elements)
        if len(my_elts) > 1:
-            my_elts[-1] = '{} {}'.format(fmt.connective, my_elts[-1])
+            my_elts[-1] = f'{fmt.connective} {my_elts[-1]}'

        if not comma_for_two_elts and len(my_elts) <= 2:
            prose = ' '.join(my_elts)
@ -351,7 +351,7 @@ class ConventionsBase(abc.ABC):
        Implemented in terms of api_prefix.

        May override."""
-        return self.api_prefix + 'VERSION_'
+        return f"{self.api_prefix}VERSION_"

    @property
    def KHR_prefix(self):
@ -360,7 +360,7 @@ class ConventionsBase(abc.ABC):
        Implemented in terms of api_prefix.

        May override."""
-        return self.api_prefix + 'KHR_'
+        return f"{self.api_prefix}KHR_"

    @property
    def EXT_prefix(self):
@ -369,7 +369,7 @@ class ConventionsBase(abc.ABC):
        Implemented in terms of api_prefix.

        May override."""
-        return self.api_prefix + 'EXT_'
+        return f"{self.api_prefix}EXT_"

    def writeFeature(self, featureName, featureExtraProtect, filename):
        """Return True if OutputGenerator.endFeature should write this feature.
@ -483,8 +483,7 @@ class ConventionsBase(abc.ABC):
           file.
            - name - extension name"""

-        return 'include::{{appendices}}/{}[]'.format(
-                self.extension_file_path(name))
+        return f'include::{{appendices}}/{self.extension_file_path(name)}[]'

    @property
    def provisional_extension_warning(self):
--- a/registry/validusage.json
+++ b/registry/validusage.json
--- a/registry/vk.xml
+++ b/registry/vk.xml
--- a/registry/vkconventions.py
+++ b/registry/vkconventions.py
@ -28,6 +28,7 @@ SPECIAL_WORDS = set((
    'ASTC',  # VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
    'D3D12',  # VkD3D12FenceSubmitInfoKHR
    'Float16',  # VkPhysicalDeviceShaderFloat16Int8FeaturesKHR
+    'Bfloat16',  # VkPhysicalDeviceShaderBfloat16FeaturesKHR
    'ImagePipe',  # VkImagePipeSurfaceCreateInfoFUCHSIA
    'Int64',  # VkPhysicalDeviceShaderAtomicInt64FeaturesKHR
    'Int8',  # VkPhysicalDeviceShaderFloat16Int8FeaturesKHR
@ -38,7 +39,7 @@ SPECIAL_WORDS = set((
 ))
 # A regex to match any of the SPECIAL_WORDS
 EXCEPTION_PATTERN = r'(?P<exception>{})'.format(
-    '|'.join('(%s)' % re.escape(w) for w in SPECIAL_WORDS))
+    '|'.join(f'({re.escape(w)})' for w in SPECIAL_WORDS))
 MAIN_RE = re.compile(
    # the negative lookahead is to prevent the all-caps pattern from being too greedy.
    r'({}|([0-9]+)|([A-Z][a-z]+)|([A-Z][A-Z]*(?![a-z])))'.format(EXCEPTION_PATTERN))
--- a/registry/vulkan_object.py
+++ b/registry/vulkan_object.py
@ -0,0 +1,438 @@
+#!/usr/bin/env python3 -i
+#
+# Copyright 2023-2025 The Khronos Group Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass, field
+from enum import IntFlag, Enum, auto
+
+@dataclass
+class Extension:
+    """<extension>"""
+    name: str # ex) VK_KHR_SURFACE
+    nameString: str # marco with string, ex) VK_KHR_SURFACE_EXTENSION_NAME
+    specVersion: str # marco with string, ex) VK_KHR_SURFACE_SPEC_VERSION
+
+    # Only one will be True, the other is False
+    instance: bool
+    device: bool
+
+    depends: (str | None)
+    vendorTag: (str | None)  # ex) EXT, KHR, etc
+    platform: (str | None)   # ex) android
+    protect: (str | None)    # ex) VK_USE_PLATFORM_ANDROID_KHR
+    provisional: bool
+    promotedTo: (str | None) # ex) VK_VERSION_1_1
+    deprecatedBy: (str | None)
+    obsoletedBy: (str | None)
+    specialUse: list[str]
+
+    # These are here to allow for easy reverse lookups
+    # Quotes allow us to forward declare the dataclass
+    commands: list['Command'] = field(default_factory=list, init=False)
+    enums:    list['Enum']    = field(default_factory=list, init=False)
+    bitmasks: list['Bitmask'] = field(default_factory=list, init=False)
+    # Use the Enum name to see what fields are extended
+    enumFields: dict[str, list['EnumField']] = field(default_factory=dict, init=False)
+    # Use the Bitmaks name to see what flags are extended
+    flags: dict[str, list['Flag']] = field(default_factory=dict, init=False)
+
+@dataclass
+class Version:
+    """
+    <feature> which represents a version
+    This will NEVER be Version 1.0, since having 'no version' is same as being 1.0
+    """
+    name: str       # ex) VK_VERSION_1_1
+    nameString: str # ex) "VK_VERSION_1_1" (no marco, so has quotes)
+    nameApi: str    # ex) VK_API_VERSION_1_1
+
+@dataclass
+class Handle:
+    """<type> which represents a dispatch handle"""
+    name: str # ex) VkBuffer
+    aliases: list[str] # ex) ['VkSamplerYcbcrConversionKHR']
+
+    type: str # ex) VK_OBJECT_TYPE_BUFFER
+    protect: (str | None) # ex) VK_USE_PLATFORM_ANDROID_KHR
+
+    parent: 'Handle' # Chain of parent handles, can be None
+
+    # Only one will be True, the other is False
+    instance: bool
+    device: bool
+
+    dispatchable: bool
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Param:
+    """<command/param>"""
+    name: str # ex) pCreateInfo, pAllocator, pBuffer
+    alias: str
+
+    # the "base type" - will not preserve the 'const' or pointer info
+    # ex) void, uint32_t, VkFormat, VkBuffer, etc
+    type: str
+    # the "full type" - will be cDeclaration without the type name
+    # ex) const void*, uint32_t, const VkFormat, VkBuffer*, etc
+    # For arrays, this will only display the type, fixedSizeArray can be used to get the length
+    fullType: str
+
+    noAutoValidity: bool
+
+    const: bool           # type contains 'const'
+    length:  (str | None) # the known length of pointer, will never be 'null-terminated'
+    nullTerminated: bool  # If a UTF-8 string, it will be null-terminated
+    pointer: bool         # type contains a pointer (include 'PFN' function pointers)
+    # Used to list how large an array of the type is
+    # ex) lineWidthRange is ['2']
+    # ex) memoryTypes is ['VK_MAX_MEMORY_TYPES']
+    # ex) VkTransformMatrixKHR:matrix is ['3', '4']
+    fixedSizeArray: list[str]
+
+    optional: bool
+    optionalPointer: bool # if type contains a pointer, is the pointer value optional
+
+    externSync: bool
+    externSyncPointer: list[str] # if type contains a pointer, might only specific members modified
+
+    # C string of member, example:
+    #   - const void* pNext
+    #   - VkFormat format
+    #   - VkStructureType sType
+    cDeclaration: str
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+class Queues(IntFlag):
+    TRANSFER       = auto() # VK_QUEUE_TRANSFER_BIT
+    GRAPHICS       = auto() # VK_QUEUE_GRAPHICS_BIT
+    COMPUTE        = auto() # VK_QUEUE_COMPUTE_BIT
+    PROTECTED      = auto() # VK_QUEUE_PROTECTED_BIT
+    SPARSE_BINDING = auto() # VK_QUEUE_SPARSE_BINDING_BIT
+    OPTICAL_FLOW   = auto() # VK_QUEUE_OPTICAL_FLOW_BIT_NV
+    DECODE         = auto() # VK_QUEUE_VIDEO_DECODE_BIT_KHR
+    ENCODE         = auto() # VK_QUEUE_VIDEO_ENCODE_BIT_KHR
+    ALL = TRANSFER | GRAPHICS | COMPUTE | PROTECTED | SPARSE_BINDING | OPTICAL_FLOW | DECODE | ENCODE
+
+class CommandScope(Enum):
+    NONE    = auto()
+    INSIDE  = auto()
+    OUTSIDE = auto()
+    BOTH    = auto()
+
+@dataclass
+class Command:
+    """<command>"""
+    name: str # ex) vkCmdDraw
+    alias: (str | None) # Because commands are interfaces into layers/drivers, we need all command alias
+    protect: (str | None) # ex) 'VK_ENABLE_BETA_EXTENSIONS'
+
+    extensions: list[Extension] # All extensions that enable the struct
+    version: (Version | None) # None if Version 1.0
+
+    returnType: str # ex) void, VkResult, etc
+
+    params: list[Param] # Each parameter of the command
+
+    # Only one will be True, the other is False
+    instance: bool
+    device: bool
+
+    tasks: list[str]        # ex) [ action, state, synchronization ]
+    queues: Queues          # zero == No Queues found
+    successCodes: list[str] # ex) [ VK_SUCCESS, VK_INCOMPLETE ]
+    errorCodes: list[str]   # ex) [ VK_ERROR_OUT_OF_HOST_MEMORY ]
+
+    # Shows support if command can be in a primary and/or secondary command buffer
+    primary: bool
+    secondary: bool
+
+    renderPass: CommandScope
+    videoCoding: CommandScope
+
+    implicitExternSyncParams: list[str]
+
+    # C prototype string - ex:
+    # VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
+    #   const VkInstanceCreateInfo* pCreateInfo,
+    #   const VkAllocationCallbacks* pAllocator,
+    #   VkInstance* pInstance);
+    cPrototype: str
+
+    # function pointer typedef  - ex:
+    # typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)
+    #   (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
+    cFunctionPointer: str
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Member:
+    """<member>"""
+    name: str # ex) sType, pNext, flags, size, usage
+
+    # the "base type" - will not preserve the 'const' or pointer info
+    # ex) void, uint32_t, VkFormat, VkBuffer, etc
+    type: str
+    # the "full type" - will be cDeclaration without the type name
+    # ex) const void*, uint32_t, const VkFormat, VkBuffer*, etc
+    # For arrays, this will only display the type, fixedSizeArray can be used to get the length
+    fullType: str
+
+    noAutoValidity: bool
+    limitType: (str | None) # ex) 'max', 'bitmask', 'bits', 'min,mul'
+
+    const: bool           # type contains 'const'
+    length:  (str | None) # the known length of pointer, will never be 'null-terminated'
+    nullTerminated: bool  # If a UTF-8 string, it will be null-terminated
+    pointer: bool         # type contains a pointer (include 'PFN' function pointers)
+    # Used to list how large an array of the type is
+    # ex) lineWidthRange is ['2']
+    # ex) memoryTypes is ['VK_MAX_MEMORY_TYPES']
+    # ex) VkTransformMatrixKHR:matrix is ['3', '4']
+    fixedSizeArray: list[str]
+
+    optional: bool
+    optionalPointer: bool # if type contains a pointer, is the pointer value optional
+
+    externSync: bool
+
+    # C string of member, example:
+    #   - const void* pNext
+    #   - VkFormat format
+    #   - VkStructureType sType
+    cDeclaration: str
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Struct:
+    """<type category="struct"> or <type category="union">"""
+    name: str # ex) VkImageSubresource2
+    aliases: list[str] # ex) ['VkImageSubresource2KHR', 'VkImageSubresource2EXT']
+
+    extensions: list[Extension] # All extensions that enable the struct
+    version: (Version | None) # None if Version 1.0
+    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
+
+    members: list[Member]
+
+    union: bool # Unions are just a subset of a Structs
+    returnedOnly: bool
+
+    sType: (str | None) # ex) VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
+    allowDuplicate: bool # can have a pNext point to itself
+
+    # These use to be list['Struct'] but some circular loops occur and cause
+    # pydevd warnings and made debugging slow (30 seconds to index a Struct)
+    extends: list[str] # Struct names that this struct extends
+    extendedBy: list[str] # Struct names that can be extended by this struct
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class EnumField:
+    """<enum> of type enum"""
+    name: str # ex) VK_DYNAMIC_STATE_SCISSOR
+    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
+
+    negative: bool # True if negative values are allowed (ex. VkResult)
+    value: int
+    valueStr: str # value as shown in spec (ex. "0", "2", "1000267000", "0x00000004")
+
+    # some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
+    extensions: list[Extension] # None if part of 1.0 core
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Enum:
+    """<enums> of type enum"""
+    name: str # ex) VkLineRasterizationMode
+    aliases: list[str] # ex) ['VkLineRasterizationModeKHR', 'VkLineRasterizationModeEXT']
+
+    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
+
+    bitWidth: int # 32 or 64 (currently all are 32, but field is to match with Bitmask)
+    returnedOnly: bool
+
+    fields: list[EnumField]
+
+    extensions: list[Extension] # None if part of 1.0 core
+    # Unique list of all extension that are involved in 'fields' (superset of 'extensions')
+    fieldExtensions: list[Extension]
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Flag:
+    """<enum> of type bitmask"""
+    name: str # ex) VK_ACCESS_2_SHADER_READ_BIT
+    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
+
+    value: int
+    valueStr: str # value as shown in spec (ex. 0x00000000", "0x00000004", "0x0000000F", "0x800000000ULL")
+    multiBit: bool # if true, more than one bit is set (ex) VK_SHADER_STAGE_ALL_GRAPHICS)
+    zero: bool     # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE)
+
+    # some fields are enabled from 2 extensions (ex) VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
+    extensions: list[Extension] # None if part of 1.0 core
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Bitmask:
+    """<enums> of type bitmask"""
+    name: str     # ex) VkAccessFlagBits2
+    aliases: list[str] # ex) ['VkAccessFlagBits2KHR']
+
+    flagName: str # ex) VkAccessFlags2
+    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
+
+    bitWidth: int # 32 or 64
+    returnedOnly: bool
+
+    flags: list[Flag]
+
+    extensions: list[Extension] # None if part of 1.0 core
+    # Unique list of all extension that are involved in 'flag' (superset of 'extensions')
+    flagExtensions: list[Extension]
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class FormatComponent:
+    """<format/component>"""
+    type: str # ex) R, G, B, A, D, S, etc
+    bits: str # will be an INT or 'compressed'
+    numericFormat: str # ex) UNORM, SINT, etc
+    planeIndex: (int | None) # None if no planeIndex in format
+
+@dataclass
+class FormatPlane:
+    """<format/plane>"""
+    index: int
+    widthDivisor: int
+    heightDivisor: int
+    compatible: str
+
+@dataclass
+class Format:
+    """<format>"""
+    name: str
+    className: str
+    blockSize: int
+    texelsPerBlock: int
+    blockExtent: list[str]
+    packed: (int | None) # None == not-packed
+    chroma: (str | None)
+    compressed: (str | None)
+    components: list[FormatComponent] # <format/component>
+    planes: list[FormatPlane]  # <format/plane>
+    spirvImageFormat: (str | None)
+
+@dataclass
+class SyncSupport:
+    """<syncsupport>"""
+    queues: Queues
+    stages: list[Flag] # VkPipelineStageFlagBits2
+    max: bool # If this supports max values
+
+@dataclass
+class SyncEquivalent:
+    """<syncequivalent>"""
+    stages: list[Flag] # VkPipelineStageFlagBits2
+    accesses: list[Flag] # VkAccessFlagBits2
+    max: bool # If this equivalent to everything
+
+@dataclass
+class SyncStage:
+    """<syncstage>"""
+    flag: Flag # VkPipelineStageFlagBits2
+    support: SyncSupport
+    equivalent: SyncEquivalent
+
+@dataclass
+class SyncAccess:
+    """<syncaccess>"""
+    flag: Flag # VkAccessFlagBits2
+    support: SyncSupport
+    equivalent: SyncEquivalent
+
+@dataclass
+class SyncPipelineStage:
+    """<syncpipelinestage>"""
+    order: (str | None)
+    before: (str | None)
+    after: (str | None)
+    value: str
+
+@dataclass
+class SyncPipeline:
+    """<syncpipeline>"""
+    name: str
+    depends: list[str]
+    stages: list[SyncPipelineStage]
+
+@dataclass
+class SpirvEnables:
+    """What is needed to enable the SPIR-V element"""
+    version: (str | None)
+    extension: (str | None)
+    struct: (str | None)
+    feature: (str | None)
+    requires: (str | None)
+    property: (str | None)
+    member: (str | None)
+    value: (str | None)
+
+@dataclass
+class Spirv:
+    """<spirvextension> and <spirvcapability>"""
+    name: str
+    # Only one will be True, the other is False
+    extension: bool
+    capability: bool
+    enable: list[SpirvEnables]
+
+# This is the global Vulkan Object that holds all the information from parsing the XML
+# This class is designed so all generator scripts can use this to obtain data
+@dataclass
+class VulkanObject():
+    headerVersion: int = 0 # value of VK_HEADER_VERSION
+
+    extensions: dict[str, Extension] = field(default_factory=dict, init=False)
+    versions:   dict[str, Version]   = field(default_factory=dict, init=False)
+
+    handles:  dict[str, Handle]      = field(default_factory=dict, init=False)
+    commands: dict[str, Command]     = field(default_factory=dict, init=False)
+    structs:  dict[str, Struct]      = field(default_factory=dict, init=False)
+    enums:    dict[str, Enum]        = field(default_factory=dict, init=False)
+    bitmasks: dict[str, Bitmask]     = field(default_factory=dict, init=False)
+    formats:  dict[str, Format]      = field(default_factory=dict, init=False)
+
+    syncStage:    list[SyncStage]    = field(default_factory=list, init=False)
+    syncAccess:   list[SyncAccess]   = field(default_factory=list, init=False)
+    syncPipeline: list[SyncPipeline] = field(default_factory=list, init=False)
+
+    spirv: list[Spirv]               = field(default_factory=list, init=False)
+
+    # ex) [ xlib : VK_USE_PLATFORM_XLIB_KHR ]
+    platforms: dict[str, str]        = field(default_factory=dict, init=False)
+    # list of all vendor Suffix names (KHR, EXT, etc. )
+    vendorTags: list[str]            = field(default_factory=list, init=False)
+    # ex) [ Queues.COMPUTE : VK_QUEUE_COMPUTE_BIT ]
+    queueBits: dict[IntFlag, str]    = field(default_factory=dict, init=False)
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@ -12,7 +12,7 @@ add_test(NAME integration.add_subdirectory
        --build-and-test ${CMAKE_CURRENT_LIST_DIR}/integration
                         ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory
        --build-generator ${CMAKE_GENERATOR}
-        --build-options -DFIND_PACKAGE_TESTING=OFF -DVULKAN_HEADERS_ENABLE_MODULE=OFF
+        --build-options -DFIND_PACKAGE_TESTING=OFF -DVULKAN_HEADERS_ENABLE_MODULE=${VULKAN_HEADERS_ENABLE_MODULE}
 )

 set(test_install_dir "${CMAKE_CURRENT_BINARY_DIR}/install")
--- a/tests/integration/CMakeLists.txt
+++ b/tests/integration/CMakeLists.txt
@ -5,9 +5,9 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 # ~~~
-cmake_minimum_required(VERSION 3.14.2)
+cmake_minimum_required(VERSION 3.22.1)

-project(API LANGUAGES C)
+project(API LANGUAGES C CXX)

 if (FIND_PACKAGE_TESTING)
    find_package(VulkanHeaders REQUIRED CONFIG)
@ -18,6 +18,9 @@ endif()
 if (NOT TARGET Vulkan::Headers)
    message(FATAL_ERROR "Vulkan::Headers target not defined")
 endif()
+if (NOT TARGET Vulkan::HppModule AND VULKAN_HEADERS_ENABLE_MODULE)
+    message(FATAL_ERROR "Vulkan::HppModule target not defined")
+endif()

 if (FIND_PACKAGE_TESTING)
    if (NOT DEFINED VulkanHeaders_VERSION)
@ -37,6 +40,9 @@ if (NOT FIND_PACKAGE_TESTING)
    if (NOT TARGET Vulkan-Headers)
        message(FATAL_ERROR "Backcompat for Vulkan-Headers target broken!")
    endif()
+    if (NOT TARGET Vulkan-HppModule AND VULKAN_HEADERS_ENABLE_MODULE)
+        message(FATAL_ERROR "Backcompat for Vulkan-HppModule target broken!")
+    endif()
 endif()

 set(CMAKE_C_STANDARD 99)
@ -71,3 +77,15 @@ target_link_libraries(vk_icd PRIVATE Vulkan::Headers)
 # vk_layer.h
 add_library(vk_layer MODULE ../vk_layer.c)
 target_link_libraries(vk_layer PRIVATE Vulkan::Headers)
+
+# vulkan.hpp
+add_library(vk_hpp MODULE ../vk_hpp.cpp)
+target_compile_features(vk_hpp PUBLIC cxx_std_11)
+target_link_libraries(vk_hpp PRIVATE Vulkan::Headers)
+
+# vulkan.cppm
+if (VULKAN_HEADERS_ENABLE_MODULE)
+    add_library(vk_hpp_module MODULE ../vk_hpp_module.cpp)
+    set_target_properties(vk_hpp_module PROPERTIES CXX_SCAN_FOR_MODULES ON)
+    target_link_libraries(vk_hpp_module PRIVATE Vulkan::HppModule)
+endif()
--- a/tests/vk_hpp.cpp
+++ b/tests/vk_hpp.cpp
@ -0,0 +1,13 @@
+/*
+ * Copyright 2025 The Khronos Group Inc.
+ * Copyright 2025 Valve Corporation
+ * Copyright 2025 LunarG, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <vulkan/vulkan.hpp>
+
+int header_version()
+{
+    return VK_HEADER_VERSION;
+}
--- a/tests/vk_hpp_module.cpp
+++ b/tests/vk_hpp_module.cpp
@ -0,0 +1,13 @@
+/*
+ * Copyright 2025 The Khronos Group Inc.
+ * Copyright 2025 Valve Corporation
+ * Copyright 2025 LunarG, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import vulkan_hpp;
+
+int test_version()
+{
+    return static_cast<int>(vk::makeApiVersion(1, 0, 0, 0));
+}
Author	SHA1	Message	Date
Jon Leech	5ceb9ed481	Update for Vulkan-Docs 1.4.312 Some checks failed ci / cmake-unix (3.22.1, ubuntu-latest) (push) Failing after 1s Details ci / cmake-unix (latest, ubuntu-latest) (push) Failing after 1s Details ci / cmake-unix-modules (latest, clang++-18, ubuntu-latest) (push) Failing after 1s Details ci / reuse (push) Failing after 1s Details ci / cmake-unix (3.22.1, macos-latest) (push) Has been cancelled Details ci / cmake-unix (latest, macos-latest) (push) Has been cancelled Details ci / cmake-windows (3.22.1) (push) Has been cancelled Details ci / cmake-windows (latest) (push) Has been cancelled Details ci / windows_clang (clang) (push) Has been cancelled Details ci / windows_clang (clang-cl) (push) Has been cancelled Details ci / cmake-windows-modules (latest, windows-latest) (push) Has been cancelled Details	2025-04-04 04:45:22 -07:00
Jan Kuhlmann	2ac81691ba	adjusted fnc name Some checks failed ci / windows_clang (clang-cl) (push) Has been cancelled Details ci / cmake-unix (3.22.1, ubuntu-latest) (push) Failing after 2s Details ci / cmake-unix (latest, ubuntu-latest) (push) Failing after 2s Details ci / cmake-unix-modules (latest, clang++-18, ubuntu-latest) (push) Failing after 1s Details ci / reuse (push) Failing after 1s Details ci / cmake-unix (latest, macos-latest) (push) Has been cancelled Details ci / cmake-windows (3.22.1) (push) Has been cancelled Details ci / cmake-windows-modules (latest, windows-latest) (push) Has been cancelled Details ci / cmake-windows (latest) (push) Has been cancelled Details ci / cmake-unix (3.22.1, macos-latest) (push) Has been cancelled Details ci / windows_clang (clang) (push) Has been cancelled Details	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	a523083f72	simplified cpp module to not require function loading	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	cb28cd1819	replaced minimal example for modules	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	24ce771ec1	fixed linewrap on windows and CXX compiler on ubuntu	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	cafcda9360	Added licenses and used included headers in minimal examples Co-authored-by: jpr42 <109434725+jpr42@users.noreply.github.com>	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	2b1e9e7409	added c++20 workflows for modules in ubuntu and windows	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	a72b4466b3	minimal compilation setups for Vulkan::Hpp and Vulkan::HppModule	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	fdc7404466	merged subdirectory tests	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	9417d66dcf	integration tests for cxx modules	2025-03-31 09:52:53 -06:00
Jon Leech	78c359741d	Update for Vulkan-Docs 1.4.311	2025-03-20 23:33:08 -07:00
Jan Kuhlmann	d64e9e156a	cmake: Rename Vulkan-Module to Vulkan-HppModule The new name better indicates that the target is for Vulkan-Hpp. The old Vulkan-Module and Vulkan::Module targets are now deprecated and users should switch to Vulkan-HppModule. Vulkan-HppModule now supports `import std` when available. The commit disables cxx_extensions when using clang-16 due to known issues.	2025-03-17 15:44:30 -06:00
Jon Leech	cacef3039d	Update for Vulkan-Docs 1.4.310	2025-03-07 05:15:59 -08:00
Tom Anderson	0f0cfd88d7	GN build: Define VK_USE_PLATFORM_XLIB_KHR This is required to define vkCreateXlibSurfaceKHR, which is required by GTK4. Depends on Dawn CL: https://dawn-review.googlesource.com/c/dawn/+/229494 Needed to fix this Chromium issue: https://g-issues.chromium.org/issues/345261080	2025-03-06 15:49:41 -06:00
Jon Leech	952f776f65	Update for Vulkan-Docs 1.4.309	2025-02-21 03:24:08 -08:00
Juan Ramos	234c4b7370	cmake: Update minimum version to 3.22.1 Matches Vulkan Validation Layers and SPIRV-Tools.	2025-02-04 16:44:38 -07:00
Jon Leech	39f924b810	Update for Vulkan-Docs 1.4.307	2025-01-30 01:57:39 -08:00
Jon Leech	e43027aa41	Update for Vulkan-Docs 1.4.306	2025-01-24 05:52:25 -08:00