Update for Vulkan-Docs 1.3.276

Note that `registry/profiles/VP_KHR_roadmap.json` was renamed from `registry/profiles/VP_KHR_roadmap_2022.json`, now that the file contains multiple roadmap profiles.
author: Jon Leech <[email protected]> 2024-01-25 03:38:43 -0800
committer: Jon Leech <[email protected]> 2024-01-25 03:53:51 -0800
commit: 170cde531f13bb367f6eaa6a392c0058a73bda03 (patch)
tree: a1bbe0693a0fa882428b3801376c0b9f0e585fb2
parent: 217e93c664ec6704ec2d8c36fa116c1a4a1e2d40 (diff)
download: Vulkan-Headers-170cde531f13bb367f6eaa6a392c0058a73bda03.tar.gz
Vulkan-Headers-170cde531f13bb367f6eaa6a392c0058a73bda03.zip
16 files changed, 6902 insertions, 1728 deletions
diff --git a/include/vulkan/vulkan.cppm b/include/vulkan/vulkan.cppm
index e54433e..cf3c71f 100644
--- a/include/vulkan/vulkan.cppm
+++ b/include/vulkan/vulkan.cppm
@@ -643,9 +643,6 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagBitsEXT;
   using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT;
 
-  //=== VK_EXT_line_rasterization ===
-  using VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT;
-
   //=== VK_KHR_pipeline_executable_properties ===
   using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR;
 
@@ -839,6 +836,10 @@ export namespace VULKAN_HPP_NAMESPACE
   //=== VK_MSFT_layered_driver ===
   using VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT;
 
+  //=== VK_KHR_line_rasterization ===
+  using VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT;
+  using VULKAN_HPP_NAMESPACE::LineRasterizationModeKHR;
+
   //=== VK_KHR_calibrated_timestamps ===
   using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
   using VULKAN_HPP_NAMESPACE::TimeDomainKHR;
@@ -1742,10 +1743,18 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::AMDDeviceCoherentMemoryExtensionName;
   using VULKAN_HPP_NAMESPACE::AMDDeviceCoherentMemorySpecVersion;
 
+  //=== VK_KHR_dynamic_rendering_local_read ===
+  using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingLocalReadExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingLocalReadSpecVersion;
+
   //=== VK_EXT_shader_image_atomic_int64 ===
   using VULKAN_HPP_NAMESPACE::EXTShaderImageAtomicInt64ExtensionName;
   using VULKAN_HPP_NAMESPACE::EXTShaderImageAtomicInt64SpecVersion;
 
+  //=== VK_KHR_shader_quad_control ===
+  using VULKAN_HPP_NAMESPACE::KHRShaderQuadControlExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRShaderQuadControlSpecVersion;
+
   //=== VK_KHR_spirv_1_4 ===
   using VULKAN_HPP_NAMESPACE::KHRSpirv14ExtensionName;
   using VULKAN_HPP_NAMESPACE::KHRSpirv14SpecVersion;
@@ -2227,6 +2236,10 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::ARMShaderCorePropertiesExtensionName;
   using VULKAN_HPP_NAMESPACE::ARMShaderCorePropertiesSpecVersion;
 
+  //=== VK_KHR_shader_subgroup_rotate ===
+  using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupRotateExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupRotateSpecVersion;
+
   //=== VK_ARM_scheduling_controls ===
   using VULKAN_HPP_NAMESPACE::ARMSchedulingControlsExtensionName;
   using VULKAN_HPP_NAMESPACE::ARMSchedulingControlsSpecVersion;
@@ -2276,6 +2289,10 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::GOOGLESurfacelessQueryExtensionName;
   using VULKAN_HPP_NAMESPACE::GOOGLESurfacelessQuerySpecVersion;
 
+  //=== VK_KHR_shader_maximal_reconvergence ===
+  using VULKAN_HPP_NAMESPACE::KHRShaderMaximalReconvergenceExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRShaderMaximalReconvergenceSpecVersion;
+
   //=== VK_EXT_image_compression_control_swapchain ===
   using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlSwapchainExtensionName;
   using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlSwapchainSpecVersion;
@@ -2427,6 +2444,14 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorExtensionName;
   using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorSpecVersion;
 
+  //=== VK_KHR_load_store_op_none ===
+  using VULKAN_HPP_NAMESPACE::KHRLoadStoreOpNoneExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRLoadStoreOpNoneSpecVersion;
+
+  //=== VK_KHR_shader_float_controls2 ===
+  using VULKAN_HPP_NAMESPACE::KHRShaderFloatControls2ExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRShaderFloatControls2SpecVersion;
+
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
   //=== VK_QNX_external_memory_screen_buffer ===
   using VULKAN_HPP_NAMESPACE::QNXExternalMemoryScreenBufferExtensionName;
@@ -2437,10 +2462,22 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverExtensionName;
   using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverSpecVersion;
 
+  //=== VK_KHR_index_type_uint8 ===
+  using VULKAN_HPP_NAMESPACE::KHRIndexTypeUint8ExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRIndexTypeUint8SpecVersion;
+
+  //=== VK_KHR_line_rasterization ===
+  using VULKAN_HPP_NAMESPACE::KHRLineRasterizationExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRLineRasterizationSpecVersion;
+
   //=== VK_KHR_calibrated_timestamps ===
   using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsExtensionName;
   using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsSpecVersion;
 
+  //=== VK_KHR_shader_expect_assume ===
+  using VULKAN_HPP_NAMESPACE::KHRShaderExpectAssumeExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRShaderExpectAssumeSpecVersion;
+
   //=== VK_KHR_maintenance6 ===
   using VULKAN_HPP_NAMESPACE::KHRMaintenance6ExtensionName;
   using VULKAN_HPP_NAMESPACE::KHRMaintenance6SpecVersion;
@@ -3531,9 +3568,17 @@ export namespace VULKAN_HPP_NAMESPACE
   //=== VK_AMD_device_coherent_memory ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD;
 
+  //=== VK_KHR_dynamic_rendering_local_read ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;
+  using VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR;
+  using VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR;
+
   //=== VK_EXT_shader_image_atomic_int64 ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
 
+  //=== VK_KHR_shader_quad_control ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR;
+
   //=== VK_EXT_memory_budget ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT;
 
@@ -3589,17 +3634,9 @@ export namespace VULKAN_HPP_NAMESPACE
   //=== VK_EXT_headless_surface ===
   using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT;
 
-  //=== VK_EXT_line_rasterization ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT;
-  using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT;
-
   //=== VK_EXT_shader_atomic_float ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT;
 
-  //=== VK_EXT_index_type_uint8 ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT;
-
   //=== VK_EXT_extended_dynamic_state ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT;
 
@@ -3986,6 +4023,9 @@ export namespace VULKAN_HPP_NAMESPACE
   //=== VK_ARM_shader_core_properties ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM;
 
+  //=== VK_KHR_shader_subgroup_rotate ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR;
+
   //=== VK_ARM_scheduling_controls ===
   using VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM;
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM;
@@ -4038,6 +4078,9 @@ export namespace VULKAN_HPP_NAMESPACE
   //=== VK_NV_linear_color_attachment ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV;
 
+  //=== VK_KHR_shader_maximal_reconvergence ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
+
   //=== VK_EXT_image_compression_control_swapchain ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
 
@@ -4220,6 +4263,9 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT;
   using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR;
 
+  //=== VK_KHR_shader_float_controls2 ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR;
+
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
   //=== VK_QNX_external_memory_screen_buffer ===
   using VULKAN_HPP_NAMESPACE::ExternalFormatQNX;
@@ -4232,10 +4278,25 @@ export namespace VULKAN_HPP_NAMESPACE
   //=== VK_MSFT_layered_driver ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT;
 
+  //=== VK_KHR_index_type_uint8 ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR;
+
+  //=== VK_KHR_line_rasterization ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR;
+  using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT;
+  using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR;
+
   //=== VK_KHR_calibrated_timestamps ===
   using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT;
   using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR;
 
+  //=== VK_KHR_shader_expect_assume ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR;
+
   //=== VK_KHR_maintenance6 ===
   using VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT;
   using VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR;
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index e182f7d..23ca0cd 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -35,7 +35,7 @@
 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
 #  if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
 #    include <dlfcn.h>
-#  elif defined( _WIN32 )
+#  elif defined( _WIN32 ) && !defined( VULKAN_HPP_NO_WIN32_PROTOTYPES )
 typedef struct HINSTANCE__ * HINSTANCE;
 #    if defined( _WIN64 )
 typedef int64_t( __stdcall * FARPROC )();
@@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <span>
 #endif
 
-static_assert( VK_HEADER_VERSION == 275, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 276, "Wrong VK_HEADER_VERSION!" );
 
 // <tuple> includes <sys/sysmacros.h> through some other header
 // this results in major(x) being resolved to gnu_dev_major(x)
@@ -919,6 +919,13 @@ namespace VULKAN_HPP_NAMESPACE
       return m_value.operator bool();
     }
 
+#    if defined( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST )
+    operator Type() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_value;
+    }
+#    endif
+
     Type const * operator->() const VULKAN_HPP_NOEXCEPT
     {
       return &m_value;
@@ -4379,6 +4386,20 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps );
     }
 
+    //=== VK_KHR_dynamic_rendering_local_read ===
+
+    void vkCmdSetRenderingAttachmentLocationsKHR( VkCommandBuffer                              commandBuffer,
+                                                  const VkRenderingAttachmentLocationInfoKHR * pLocationInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetRenderingAttachmentLocationsKHR( commandBuffer, pLocationInfo );
+    }
+
+    void vkCmdSetRenderingInputAttachmentIndicesKHR( VkCommandBuffer                                commandBuffer,
+                                                     const VkRenderingInputAttachmentIndexInfoKHR * pLocationInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetRenderingInputAttachmentIndicesKHR( commandBuffer, pLocationInfo );
+    }
+
     //=== VK_EXT_buffer_device_address ===
 
     VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
@@ -5482,11 +5503,6 @@ namespace VULKAN_HPP_NAMESPACE
 
     //=== VK_EXT_extended_dynamic_state3 ===
 
-    void vkCmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetTessellationDomainOriginEXT( commandBuffer, domainOrigin );
-    }
-
     void vkCmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT
     {
       return ::vkCmdSetDepthClampEnableEXT( commandBuffer, depthClampEnable );
@@ -5546,6 +5562,11 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetColorWriteMaskEXT( commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks );
     }
 
+    void vkCmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetTessellationDomainOriginEXT( commandBuffer, domainOrigin );
+    }
+
     void vkCmdSetRasterizationStreamEXT( VkCommandBuffer commandBuffer, uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT
     {
       return ::vkCmdSetRasterizationStreamEXT( commandBuffer, rasterizationStream );
@@ -5838,6 +5859,13 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
+    //=== VK_KHR_line_rasterization ===
+
+    void vkCmdSetLineStippleKHR( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetLineStippleKHR( commandBuffer, lineStippleFactor, lineStipplePattern );
+    }
+
     //=== VK_KHR_calibrated_timestamps ===
 
     VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( VkPhysicalDevice  physicalDevice,
@@ -7830,10 +7858,18 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemoryExtensionName = VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemorySpecVersion   = VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION;
 
+  //=== VK_KHR_dynamic_rendering_local_read ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadExtensionName = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadSpecVersion   = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION;
+
   //=== VK_EXT_shader_image_atomic_int64 ===
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64ExtensionName = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64SpecVersion   = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION;
 
+  //=== VK_KHR_shader_quad_control ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderQuadControlExtensionName = VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderQuadControlSpecVersion   = VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION;
+
   //=== VK_KHR_spirv_1_4 ===
   VULKAN_HPP_DEPRECATED( "The VK_KHR_spirv_1_4 extension has been promoted to core in version 1.2." )
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRSpirv14ExtensionName = VK_KHR_SPIRV_1_4_EXTENSION_NAME;
@@ -7947,8 +7983,10 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostQueryResetSpecVersion = VK_EXT_HOST_QUERY_RESET_SPEC_VERSION;
 
   //=== VK_EXT_index_type_uint8 ===
+  VULKAN_HPP_DEPRECATED( "The VK_EXT_index_type_uint8 extension has been promoted to VK_KHR_index_type_uint8." )
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8ExtensionName = VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME;
-  VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8SpecVersion   = VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION;
+  VULKAN_HPP_DEPRECATED( "The VK_EXT_index_type_uint8 extension has been promoted to VK_KHR_index_type_uint8." )
+  VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8SpecVersion = VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION;
 
   //=== VK_EXT_extended_dynamic_state ===
   VULKAN_HPP_DEPRECATED( "The VK_EXT_extended_dynamic_state extension has been promoted to core in version 1.3." )
@@ -8345,8 +8383,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   //=== VK_EXT_load_store_op_none ===
+  VULKAN_HPP_DEPRECATED( "The VK_EXT_load_store_op_none extension has been promoted to VK_KHR_load_store_op_none." )
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTLoadStoreOpNoneExtensionName = VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME;
-  VULKAN_HPP_CONSTEXPR_INLINE auto EXTLoadStoreOpNoneSpecVersion   = VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION;
+  VULKAN_HPP_DEPRECATED( "The VK_EXT_load_store_op_none extension has been promoted to VK_KHR_load_store_op_none." )
+  VULKAN_HPP_CONSTEXPR_INLINE auto EXTLoadStoreOpNoneSpecVersion = VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION;
 
   //=== VK_HUAWEI_cluster_culling_shader ===
   VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIClusterCullingShaderExtensionName = VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME;
@@ -8370,6 +8410,10 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCorePropertiesExtensionName = VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCorePropertiesSpecVersion   = VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION;
 
+  //=== VK_KHR_shader_subgroup_rotate ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupRotateExtensionName = VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupRotateSpecVersion   = VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION;
+
   //=== VK_ARM_scheduling_controls ===
   VULKAN_HPP_CONSTEXPR_INLINE auto ARMSchedulingControlsExtensionName = VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto ARMSchedulingControlsSpecVersion   = VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION;
@@ -8418,6 +8462,10 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLESurfacelessQueryExtensionName = VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLESurfacelessQuerySpecVersion   = VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION;
 
+  //=== VK_KHR_shader_maximal_reconvergence ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderMaximalReconvergenceExtensionName = VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderMaximalReconvergenceSpecVersion   = VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION;
+
   //=== VK_EXT_image_compression_control_swapchain ===
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSwapchainExtensionName = VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSwapchainSpecVersion   = VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION;
@@ -8568,6 +8616,14 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorExtensionName = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorSpecVersion   = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION;
 
+  //=== VK_KHR_load_store_op_none ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneExtensionName = VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneSpecVersion   = VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION;
+
+  //=== VK_KHR_shader_float_controls2 ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2ExtensionName = VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2SpecVersion   = VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION;
+
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
   //=== VK_QNX_external_memory_screen_buffer ===
   VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferExtensionName = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME;
@@ -8578,10 +8634,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto MSFTLayeredDriverExtensionName = VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto MSFTLayeredDriverSpecVersion   = VK_MSFT_LAYERED_DRIVER_SPEC_VERSION;
 
+  //=== VK_KHR_index_type_uint8 ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8ExtensionName = VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8SpecVersion   = VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION;
+
+  //=== VK_KHR_line_rasterization ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationExtensionName = VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationSpecVersion   = VK_KHR_LINE_RASTERIZATION_SPEC_VERSION;
+
   //=== VK_KHR_calibrated_timestamps ===
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsExtensionName = VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsSpecVersion   = VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION;
 
+  //=== VK_KHR_shader_expect_assume ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderExpectAssumeExtensionName = VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderExpectAssumeSpecVersion   = VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION;
+
   //=== VK_KHR_maintenance6 ===
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance6ExtensionName = VK_KHR_MAINTENANCE_6_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance6SpecVersion   = VK_KHR_MAINTENANCE_6_SPEC_VERSION;
@@ -12257,6 +12325,61 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_KHR_dynamic_rendering_local_read ===
+  template <>
+  struct StructExtends<PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<RenderingAttachmentLocationInfoKHR, GraphicsPipelineCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<RenderingAttachmentLocationInfoKHR, CommandBufferInheritanceInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<RenderingInputAttachmentIndexInfoKHR, GraphicsPipelineCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<RenderingInputAttachmentIndexInfoKHR, CommandBufferInheritanceInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_EXT_shader_image_atomic_int64 ===
   template <>
   struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, PhysicalDeviceFeatures2>
@@ -12276,6 +12399,25 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_KHR_shader_quad_control ===
+  template <>
+  struct StructExtends<PhysicalDeviceShaderQuadControlFeaturesKHR, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceShaderQuadControlFeaturesKHR, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_EXT_memory_budget ===
   template <>
   struct StructExtends<PhysicalDeviceMemoryBudgetPropertiesEXT, PhysicalDeviceMemoryProperties2>
@@ -12579,43 +12721,6 @@ namespace VULKAN_HPP_NAMESPACE
   };
 #  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  //=== VK_EXT_line_rasterization ===
-  template <>
-  struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, PhysicalDeviceFeatures2>
-  {
-    enum
-    {
-      value = true
-    };
-  };
-
-  template <>
-  struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, DeviceCreateInfo>
-  {
-    enum
-    {
-      value = true
-    };
-  };
-
-  template <>
-  struct StructExtends<PhysicalDeviceLineRasterizationPropertiesEXT, PhysicalDeviceProperties2>
-  {
-    enum
-    {
-      value = true
-    };
-  };
-
-  template <>
-  struct StructExtends<PipelineRasterizationLineStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>
-  {
-    enum
-    {
-      value = true
-    };
-  };
-
   //=== VK_EXT_shader_atomic_float ===
   template <>
   struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, PhysicalDeviceFeatures2>
@@ -12635,25 +12740,6 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
-  //=== VK_EXT_index_type_uint8 ===
-  template <>
-  struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, PhysicalDeviceFeatures2>
-  {
-    enum
-    {
-      value = true
-    };
-  };
-
-  template <>
-  struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, DeviceCreateInfo>
-  {
-    enum
-    {
-      value = true
-    };
-  };
-
   //=== VK_EXT_extended_dynamic_state ===
   template <>
   struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>
@@ -14702,6 +14788,25 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_KHR_shader_subgroup_rotate ===
+  template <>
+  struct StructExtends<PhysicalDeviceShaderSubgroupRotateFeaturesKHR, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceShaderSubgroupRotateFeaturesKHR, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_ARM_scheduling_controls ===
   template <>
   struct StructExtends<DeviceQueueShaderCoreControlCreateInfoARM, DeviceQueueCreateInfo>
@@ -15019,6 +15124,25 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_KHR_shader_maximal_reconvergence ===
+  template <>
+  struct StructExtends<PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_EXT_image_compression_control_swapchain ===
   template <>
   struct StructExtends<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, PhysicalDeviceFeatures2>
@@ -16138,6 +16262,25 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_KHR_shader_float_controls2 ===
+  template <>
+  struct StructExtends<PhysicalDeviceShaderFloatControls2FeaturesKHR, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceShaderFloatControls2FeaturesKHR, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
 #  if defined( VK_USE_PLATFORM_SCREEN_QNX )
   //=== VK_QNX_external_memory_screen_buffer ===
   template <>
@@ -16205,6 +16348,81 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_KHR_index_type_uint8 ===
+  template <>
+  struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesKHR, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesKHR, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  //=== VK_KHR_line_rasterization ===
+  template <>
+  struct StructExtends<PhysicalDeviceLineRasterizationFeaturesKHR, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceLineRasterizationFeaturesKHR, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceLineRasterizationPropertiesKHR, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PipelineRasterizationLineStateCreateInfoKHR, PipelineRasterizationStateCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  //=== VK_KHR_shader_expect_assume ===
+  template <>
+  struct StructExtends<PhysicalDeviceShaderExpectAssumeFeaturesKHR, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceShaderExpectAssumeFeaturesKHR, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_KHR_maintenance6 ===
   template <>
   struct StructExtends<PhysicalDeviceMaintenance6FeaturesKHR, PhysicalDeviceFeatures2>
@@ -17099,6 +17317,10 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0;
     PFN_vkCmdSetFragmentShadingRateKHR             vkCmdSetFragmentShadingRateKHR             = 0;
 
+    //=== VK_KHR_dynamic_rendering_local_read ===
+    PFN_vkCmdSetRenderingAttachmentLocationsKHR    vkCmdSetRenderingAttachmentLocationsKHR    = 0;
+    PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR = 0;
+
     //=== VK_EXT_buffer_device_address ===
     PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0;
 
@@ -17412,7 +17634,6 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkGetPipelineIndirectDeviceAddressNV      vkGetPipelineIndirectDeviceAddressNV      = 0;
 
     //=== VK_EXT_extended_dynamic_state3 ===
-    PFN_vkCmdSetTessellationDomainOriginEXT         vkCmdSetTessellationDomainOriginEXT         = 0;
     PFN_vkCmdSetDepthClampEnableEXT                 vkCmdSetDepthClampEnableEXT                 = 0;
     PFN_vkCmdSetPolygonModeEXT                      vkCmdSetPolygonModeEXT                      = 0;
     PFN_vkCmdSetRasterizationSamplesEXT             vkCmdSetRasterizationSamplesEXT             = 0;
@@ -17423,6 +17644,7 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCmdSetColorBlendEnableEXT                 vkCmdSetColorBlendEnableEXT                 = 0;
     PFN_vkCmdSetColorBlendEquationEXT               vkCmdSetColorBlendEquationEXT               = 0;
     PFN_vkCmdSetColorWriteMaskEXT                   vkCmdSetColorWriteMaskEXT                   = 0;
+    PFN_vkCmdSetTessellationDomainOriginEXT         vkCmdSetTessellationDomainOriginEXT         = 0;
     PFN_vkCmdSetRasterizationStreamEXT              vkCmdSetRasterizationStreamEXT              = 0;
     PFN_vkCmdSetConservativeRasterizationModeEXT    vkCmdSetConservativeRasterizationModeEXT    = 0;
     PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT = 0;
@@ -17491,6 +17713,9 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder                    = 0;
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
+    //=== VK_KHR_line_rasterization ===
+    PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0;
+
     //=== VK_KHR_calibrated_timestamps ===
     PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0;
     PFN_vkGetCalibratedTimestampsKHR                   vkGetCalibratedTimestampsKHR                   = 0;
@@ -18400,6 +18625,12 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) );
       vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateKHR" ) );
 
+      //=== VK_KHR_dynamic_rendering_local_read ===
+      vkCmdSetRenderingAttachmentLocationsKHR =
+        PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingAttachmentLocationsKHR" ) );
+      vkCmdSetRenderingInputAttachmentIndicesKHR =
+        PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) );
+
       //=== VK_EXT_buffer_device_address ===
       vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) );
       if ( !vkGetBufferDeviceAddress )
@@ -18449,6 +18680,8 @@ namespace VULKAN_HPP_NAMESPACE
 
       //=== VK_EXT_line_rasterization ===
       vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) );
+      if ( !vkCmdSetLineStippleKHR )
+        vkCmdSetLineStippleKHR = vkCmdSetLineStippleEXT;
 
       //=== VK_EXT_host_query_reset ===
       vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) );
@@ -18795,7 +19028,6 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetInstanceProcAddr( instance, "vkGetPipelineIndirectDeviceAddressNV" ) );
 
       //=== VK_EXT_extended_dynamic_state3 ===
-      vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetInstanceProcAddr( instance, "vkCmdSetTessellationDomainOriginEXT" ) );
       vkCmdSetDepthClampEnableEXT         = PFN_vkCmdSetDepthClampEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClampEnableEXT" ) );
       vkCmdSetPolygonModeEXT              = PFN_vkCmdSetPolygonModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPolygonModeEXT" ) );
       vkCmdSetRasterizationSamplesEXT     = PFN_vkCmdSetRasterizationSamplesEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationSamplesEXT" ) );
@@ -18806,6 +19038,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdSetColorBlendEnableEXT         = PFN_vkCmdSetColorBlendEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEnableEXT" ) );
       vkCmdSetColorBlendEquationEXT       = PFN_vkCmdSetColorBlendEquationEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEquationEXT" ) );
       vkCmdSetColorWriteMaskEXT           = PFN_vkCmdSetColorWriteMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteMaskEXT" ) );
+      vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetInstanceProcAddr( instance, "vkCmdSetTessellationDomainOriginEXT" ) );
       vkCmdSetRasterizationStreamEXT      = PFN_vkCmdSetRasterizationStreamEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationStreamEXT" ) );
       vkCmdSetConservativeRasterizationModeEXT =
         PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetConservativeRasterizationModeEXT" ) );
@@ -18883,6 +19116,9 @@ namespace VULKAN_HPP_NAMESPACE
       vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetInstanceProcAddr( instance, "vkGetScreenBufferPropertiesQNX" ) );
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
+      //=== VK_KHR_line_rasterization ===
+      vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleKHR" ) );
+
       //=== VK_KHR_calibrated_timestamps ===
       vkGetPhysicalDeviceCalibrateableTimeDomainsKHR =
         PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) );
@@ -19493,6 +19729,12 @@ namespace VULKAN_HPP_NAMESPACE
       //=== VK_KHR_fragment_shading_rate ===
       vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) );
 
+      //=== VK_KHR_dynamic_rendering_local_read ===
+      vkCmdSetRenderingAttachmentLocationsKHR =
+        PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocationsKHR" ) );
+      vkCmdSetRenderingInputAttachmentIndicesKHR =
+        PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) );
+
       //=== VK_EXT_buffer_device_address ===
       vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) );
       if ( !vkGetBufferDeviceAddress )
@@ -19523,6 +19765,8 @@ namespace VULKAN_HPP_NAMESPACE
 
       //=== VK_EXT_line_rasterization ===
       vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
+      if ( !vkCmdSetLineStippleKHR )
+        vkCmdSetLineStippleKHR = vkCmdSetLineStippleEXT;
 
       //=== VK_EXT_host_query_reset ===
       vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) );
@@ -19838,7 +20082,6 @@ namespace VULKAN_HPP_NAMESPACE
       vkGetPipelineIndirectDeviceAddressNV = PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectDeviceAddressNV" ) );
 
       //=== VK_EXT_extended_dynamic_state3 ===
-      vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) );
       vkCmdSetDepthClampEnableEXT         = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) );
       vkCmdSetPolygonModeEXT              = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) );
       vkCmdSetRasterizationSamplesEXT     = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) );
@@ -19849,6 +20092,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdSetColorBlendEnableEXT         = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) );
       vkCmdSetColorBlendEquationEXT       = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) );
       vkCmdSetColorWriteMaskEXT           = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) );
+      vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) );
       vkCmdSetRasterizationStreamEXT      = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) );
       vkCmdSetConservativeRasterizationModeEXT =
         PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) );
@@ -19918,6 +20162,9 @@ namespace VULKAN_HPP_NAMESPACE
       vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) );
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
+      //=== VK_KHR_line_rasterization ===
+      vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleKHR" ) );
+
       //=== VK_KHR_calibrated_timestamps ===
       vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) );
 
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index 7d8bb4c..10d97d8 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -69,7 +69,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 275
+#define VK_HEADER_VERSION 276
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@@ -718,7 +718,11 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR = 1000232000,
+    VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR = 1000232001,
+    VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR = 1000232002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR = 1000235000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
     VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
@@ -743,11 +747,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
     VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
-    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
     VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
@@ -959,6 +959,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = 1000416000,
     VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002,
@@ -985,6 +986,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001,
     VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR = 1000434000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001,
@@ -1075,13 +1077,19 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR = 1000525000,
     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR = 1000190001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR = 1000190002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR = 1000528000,
     VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000,
     VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001,
     VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002,
     VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR = 1000265000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR = 1000259000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR = 1000259001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR = 1000259002,
     VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR = 1000184000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR = 1000544000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR = 1000545000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR = 1000545001,
     VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR = 1000545002,
@@ -1227,7 +1235,11 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
     VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES,
@@ -1304,6 +1316,7 @@ typedef enum VkImageLayout {
     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
     VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
     VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003,
+    VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR = 1000232000,
     VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000,
     VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001,
     VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002,
@@ -1909,12 +1922,10 @@ typedef enum VkDynamicState {
     VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000,
     VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
     VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000,
-    VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
     VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000,
     VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000,
     VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003,
     VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000,
-    VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002,
     VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003,
     VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004,
     VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005,
@@ -1925,6 +1936,7 @@ typedef enum VkDynamicState {
     VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010,
     VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011,
     VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012,
+    VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002,
     VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013,
     VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014,
     VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015,
@@ -1946,6 +1958,8 @@ typedef enum VkDynamicState {
     VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031,
     VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032,
     VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000,
+    VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = 1000259000,
+    VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR,
     VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE,
     VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE,
     VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY,
@@ -2094,7 +2108,8 @@ typedef enum VkAttachmentLoadOp {
     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
-    VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000,
+    VK_ATTACHMENT_LOAD_OP_NONE_KHR = 1000400000,
+    VK_ATTACHMENT_LOAD_OP_NONE_EXT = VK_ATTACHMENT_LOAD_OP_NONE_KHR,
     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
 } VkAttachmentLoadOp;
 
@@ -2130,8 +2145,9 @@ typedef enum VkIndexType {
     VK_INDEX_TYPE_UINT16 = 0,
     VK_INDEX_TYPE_UINT32 = 1,
     VK_INDEX_TYPE_NONE_KHR = 1000165000,
-    VK_INDEX_TYPE_UINT8_EXT = 1000265000,
+    VK_INDEX_TYPE_UINT8_KHR = 1000265000,
     VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR,
+    VK_INDEX_TYPE_UINT8_EXT = VK_INDEX_TYPE_UINT8_KHR,
     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkIndexType;
 
@@ -10196,6 +10212,58 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(
 #endif
 
 
+// VK_KHR_dynamic_rendering_local_read is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_dynamic_rendering_local_read 1
+#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION 1
+#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME "VK_KHR_dynamic_rendering_local_read"
+typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           dynamicRenderingLocalRead;
+} VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;
+
+typedef struct VkRenderingAttachmentLocationInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           colorAttachmentCount;
+    const uint32_t*    pColorAttachmentLocations;
+} VkRenderingAttachmentLocationInfoKHR;
+
+typedef struct VkRenderingInputAttachmentIndexInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           colorAttachmentCount;
+    const uint32_t*    pColorAttachmentInputIndices;
+    const uint32_t*    pDepthInputAttachmentIndex;
+    const uint32_t*    pStencilInputAttachmentIndex;
+} VkRenderingInputAttachmentIndexInfoKHR;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocationsKHR)(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfoKHR* pLocationInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR* pLocationInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkRenderingAttachmentLocationInfoKHR* pLocationInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkRenderingInputAttachmentIndexInfoKHR* pLocationInfo);
+#endif
+
+
+// VK_KHR_shader_quad_control is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_quad_control 1
+#define VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION 1
+#define VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME "VK_KHR_shader_quad_control"
+typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderQuadControl;
+} VkPhysicalDeviceShaderQuadControlFeaturesKHR;
+
+
+
 // VK_KHR_spirv_1_4 is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_spirv_1_4 1
 #define VK_KHR_SPIRV_1_4_SPEC_VERSION     1
@@ -10976,6 +11044,31 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(
 #endif
 
 
+// VK_KHR_shader_subgroup_rotate is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_subgroup_rotate 1
+#define VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION 1
+#define VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME "VK_KHR_shader_subgroup_rotate"
+typedef struct VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderSubgroupRotate;
+    VkBool32           shaderSubgroupRotateClustered;
+} VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR;
+
+
+
+// VK_KHR_shader_maximal_reconvergence is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_maximal_reconvergence 1
+#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION 1
+#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME "VK_KHR_shader_maximal_reconvergence"
+typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderMaximalReconvergence;
+} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
+
+
+
 // VK_KHR_maintenance5 is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_maintenance5 1
 #define VK_KHR_MAINTENANCE_5_SPEC_VERSION 1
@@ -11284,6 +11377,88 @@ typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR {
 
 
 
+// VK_KHR_load_store_op_none is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_load_store_op_none 1
+#define VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION 1
+#define VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_KHR_load_store_op_none"
+
+
+// VK_KHR_shader_float_controls2 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_float_controls2 1
+#define VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION 1
+#define VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME "VK_KHR_shader_float_controls2"
+typedef struct VkPhysicalDeviceShaderFloatControls2FeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderFloatControls2;
+} VkPhysicalDeviceShaderFloatControls2FeaturesKHR;
+
+
+
+// VK_KHR_index_type_uint8 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_index_type_uint8 1
+#define VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION 1
+#define VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_KHR_index_type_uint8"
+typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           indexTypeUint8;
+} VkPhysicalDeviceIndexTypeUint8FeaturesKHR;
+
+
+
+// VK_KHR_line_rasterization is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_line_rasterization 1
+#define VK_KHR_LINE_RASTERIZATION_SPEC_VERSION 1
+#define VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME "VK_KHR_line_rasterization"
+
+typedef enum VkLineRasterizationModeKHR {
+    VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR = 0,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR = 1,
+    VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR = 2,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR = 3,
+    VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR,
+    VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR,
+    VK_LINE_RASTERIZATION_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkLineRasterizationModeKHR;
+typedef struct VkPhysicalDeviceLineRasterizationFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           rectangularLines;
+    VkBool32           bresenhamLines;
+    VkBool32           smoothLines;
+    VkBool32           stippledRectangularLines;
+    VkBool32           stippledBresenhamLines;
+    VkBool32           stippledSmoothLines;
+} VkPhysicalDeviceLineRasterizationFeaturesKHR;
+
+typedef struct VkPhysicalDeviceLineRasterizationPropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           lineSubPixelPrecisionBits;
+} VkPhysicalDeviceLineRasterizationPropertiesKHR;
+
+typedef struct VkPipelineRasterizationLineStateCreateInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkLineRasterizationModeKHR    lineRasterizationMode;
+    VkBool32                      stippledLineEnable;
+    uint32_t                      lineStippleFactor;
+    uint16_t                      lineStipplePattern;
+} VkPipelineRasterizationLineStateCreateInfoKHR;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleKHR)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleKHR(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern);
+#endif
+
+
 // VK_KHR_calibrated_timestamps is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_calibrated_timestamps 1
 #define VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1
@@ -11324,6 +11499,18 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR(
 #endif
 
 
+// VK_KHR_shader_expect_assume is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_expect_assume 1
+#define VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION 1
+#define VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME "VK_KHR_shader_expect_assume"
+typedef struct VkPhysicalDeviceShaderExpectAssumeFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderExpectAssume;
+} VkPhysicalDeviceShaderExpectAssumeFeaturesKHR;
+
+
+
 // VK_KHR_maintenance6 is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_maintenance6 1
 #define VK_KHR_MAINTENANCE_6_SPEC_VERSION 1
@@ -14652,39 +14839,13 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(
 #define VK_EXT_line_rasterization 1
 #define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1
 #define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"
+typedef VkLineRasterizationModeKHR VkLineRasterizationModeEXT;
 
-typedef enum VkLineRasterizationModeEXT {
-    VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
-    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
-    VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
-    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
-    VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkLineRasterizationModeEXT;
-typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           rectangularLines;
-    VkBool32           bresenhamLines;
-    VkBool32           smoothLines;
-    VkBool32           stippledRectangularLines;
-    VkBool32           stippledBresenhamLines;
-    VkBool32           stippledSmoothLines;
-} VkPhysicalDeviceLineRasterizationFeaturesEXT;
+typedef VkPhysicalDeviceLineRasterizationFeaturesKHR VkPhysicalDeviceLineRasterizationFeaturesEXT;
 
-typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    uint32_t           lineSubPixelPrecisionBits;
-} VkPhysicalDeviceLineRasterizationPropertiesEXT;
+typedef VkPhysicalDeviceLineRasterizationPropertiesKHR VkPhysicalDeviceLineRasterizationPropertiesEXT;
 
-typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {
-    VkStructureType               sType;
-    const void*                   pNext;
-    VkLineRasterizationModeEXT    lineRasterizationMode;
-    VkBool32                      stippledLineEnable;
-    uint32_t                      lineStippleFactor;
-    uint16_t                      lineStipplePattern;
-} VkPipelineRasterizationLineStateCreateInfoEXT;
+typedef VkPipelineRasterizationLineStateCreateInfoKHR VkPipelineRasterizationLineStateCreateInfoEXT;
 
 typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
 
@@ -14740,11 +14901,7 @@ VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(
 #define VK_EXT_index_type_uint8 1
 #define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1
 #define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"
-typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           indexTypeUint8;
-} VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
+typedef VkPhysicalDeviceIndexTypeUint8FeaturesKHR VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
 
 
 
@@ -17769,7 +17926,6 @@ typedef struct VkColorBlendAdvancedEXT {
     VkBool32             clampResults;
 } VkColorBlendAdvancedEXT;
 
-typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin);
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable);
 typedef void (VKAPI_PTR *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode);
 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits  rasterizationSamples);
@@ -17780,6 +17936,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBu
 typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables);
 typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations);
 typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks);
+typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin);
 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream);
 typedef void (VKAPI_PTR *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode);
 typedef void (VKAPI_PTR *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize);
@@ -17802,10 +17959,6 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkComma
 typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode);
 
 #ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(
-    VkCommandBuffer                             commandBuffer,
-    VkTessellationDomainOrigin                  domainOrigin);
-
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    depthClampEnable);
@@ -17853,6 +18006,10 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT(
     uint32_t                                    attachmentCount,
     const VkColorComponentFlags*                pColorWriteMasks);
 
+VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkTessellationDomainOrigin                  domainOrigin);
+
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    rasterizationStream);
diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp
index 5dabb74..b242eff 100644
--- a/include/vulkan/vulkan_enums.hpp
+++ b/include/vulkan/vulkan_enums.hpp
@@ -958,7 +958,11 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceFragmentShadingRateKHR                     = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR,
     ePhysicalDeviceShaderCoreProperties2AMD                   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD,
     ePhysicalDeviceCoherentMemoryFeaturesAMD                  = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,
+    ePhysicalDeviceDynamicRenderingLocalReadFeaturesKHR       = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR,
+    eRenderingAttachmentLocationInfoKHR                       = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR,
+    eRenderingInputAttachmentIndexInfoKHR                     = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR,
     ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT          = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT,
+    ePhysicalDeviceShaderQuadControlFeaturesKHR               = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR,
     ePhysicalDeviceMemoryBudgetPropertiesEXT                  = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
     ePhysicalDeviceMemoryPriorityFeaturesEXT                  = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
     eMemoryPriorityAllocateInfoEXT                            = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
@@ -1263,6 +1267,7 @@ namespace VULKAN_HPP_NAMESPACE
     eDeviceBufferMemoryRequirementsKHR                           = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR,
     eDeviceImageMemoryRequirementsKHR                            = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR,
     ePhysicalDeviceShaderCorePropertiesARM                       = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM,
+    ePhysicalDeviceShaderSubgroupRotateFeaturesKHR               = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR,
     eDeviceQueueShaderCoreControlCreateInfoARM                   = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM,
     ePhysicalDeviceSchedulingControlsFeaturesARM                 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM,
     ePhysicalDeviceSchedulingControlsPropertiesARM               = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM,
@@ -1289,6 +1294,7 @@ namespace VULKAN_HPP_NAMESPACE
     eComputePipelineIndirectBufferInfoNV                         = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV,
     ePipelineIndirectDeviceAddressInfoNV                         = VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV,
     ePhysicalDeviceLinearColorAttachmentFeaturesNV               = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV,
+    ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR         = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR,
     ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT,
     ePhysicalDeviceImageProcessingFeaturesQCOM                   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM,
     ePhysicalDeviceImageProcessingPropertiesQCOM                 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM,
@@ -1382,6 +1388,7 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceVertexAttributeDivisorPropertiesKHR           = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR,
     ePipelineVertexInputDivisorStateCreateInfoKHR                = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR,
     ePhysicalDeviceVertexAttributeDivisorFeaturesKHR             = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR,
+    ePhysicalDeviceShaderFloatControls2FeaturesKHR               = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR,
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
     eScreenBufferPropertiesQNX                           = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX,
     eScreenBufferFormatPropertiesQNX                     = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX,
@@ -1390,7 +1397,12 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX,
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
     ePhysicalDeviceLayeredDriverPropertiesMSFT            = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT,
+    ePhysicalDeviceIndexTypeUint8FeaturesKHR              = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR,
+    ePhysicalDeviceLineRasterizationFeaturesKHR           = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR,
+    ePipelineRasterizationLineStateCreateInfoKHR          = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR,
+    ePhysicalDeviceLineRasterizationPropertiesKHR         = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR,
     eCalibratedTimestampInfoKHR                           = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR,
+    ePhysicalDeviceShaderExpectAssumeFeaturesKHR          = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR,
     ePhysicalDeviceMaintenance6FeaturesKHR                = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR,
     ePhysicalDeviceMaintenance6PropertiesKHR              = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR,
     eBindMemoryStatusKHR                                  = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR,
@@ -2502,6 +2514,7 @@ namespace VULKAN_HPP_NAMESPACE
     eShadingRateOptimalNV                     = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV,
     eFragmentDensityMapOptimalEXT             = VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT,
     eFragmentShadingRateAttachmentOptimalKHR  = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR,
+    eRenderingLocalReadKHR                    = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR,
     eDepthAttachmentOptimalKHR                = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR,
     eDepthReadOnlyOptimalKHR                  = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR,
     eStencilAttachmentOptimalKHR              = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR,
@@ -2765,7 +2778,6 @@ namespace VULKAN_HPP_NAMESPACE
     eLogicOpEXT                          = VK_DYNAMIC_STATE_LOGIC_OP_EXT,
     ePrimitiveRestartEnableEXT           = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT,
     eColorWriteEnableEXT                 = VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT,
-    eTessellationDomainOriginEXT         = VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT,
     eDepthClampEnableEXT                 = VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT,
     ePolygonModeEXT                      = VK_DYNAMIC_STATE_POLYGON_MODE_EXT,
     eRasterizationSamplesEXT             = VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT,
@@ -2776,6 +2788,7 @@ namespace VULKAN_HPP_NAMESPACE
     eColorBlendEnableEXT                 = VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
     eColorBlendEquationEXT               = VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
     eColorWriteMaskEXT                   = VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,
+    eTessellationDomainOriginEXT         = VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT,
     eRasterizationStreamEXT              = VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT,
     eConservativeRasterizationModeEXT    = VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT,
     eExtraPrimitiveOverestimationSizeEXT = VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT,
@@ -2796,7 +2809,8 @@ namespace VULKAN_HPP_NAMESPACE
     eShadingRateImageEnableNV            = VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV,
     eRepresentativeFragmentTestEnableNV  = VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV,
     eCoverageReductionModeNV             = VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV,
-    eAttachmentFeedbackLoopEnableEXT     = VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT
+    eAttachmentFeedbackLoopEnableEXT     = VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT,
+    eLineStippleKHR                      = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR
   };
 
   enum class FrontFace
@@ -3349,7 +3363,8 @@ namespace VULKAN_HPP_NAMESPACE
     eLoad     = VK_ATTACHMENT_LOAD_OP_LOAD,
     eClear    = VK_ATTACHMENT_LOAD_OP_CLEAR,
     eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-    eNoneEXT  = VK_ATTACHMENT_LOAD_OP_NONE_EXT
+    eNoneEXT  = VK_ATTACHMENT_LOAD_OP_NONE_EXT,
+    eNoneKHR  = VK_ATTACHMENT_LOAD_OP_NONE_KHR
   };
 
   enum class AttachmentStoreOp
@@ -3539,7 +3554,8 @@ namespace VULKAN_HPP_NAMESPACE
     eUint32   = VK_INDEX_TYPE_UINT32,
     eNoneKHR  = VK_INDEX_TYPE_NONE_KHR,
     eNoneNV   = VK_INDEX_TYPE_NONE_NV,
-    eUint8EXT = VK_INDEX_TYPE_UINT8_EXT
+    eUint8EXT = VK_INDEX_TYPE_UINT8_EXT,
+    eUint8KHR = VK_INDEX_TYPE_UINT8_KHR
   };
 
   enum class StencilFaceFlagBits : VkStencilFaceFlags
@@ -6024,16 +6040,6 @@ namespace VULKAN_HPP_NAMESPACE
     static VULKAN_HPP_CONST_OR_CONSTEXPR HeadlessSurfaceCreateFlagsEXT allFlags  = {};
   };
 
-  //=== VK_EXT_line_rasterization ===
-
-  enum class LineRasterizationModeEXT
-  {
-    eDefault           = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT,
-    eRectangular       = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT,
-    eBresenham         = VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT,
-    eRectangularSmooth = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT
-  };
-
   //=== VK_KHR_pipeline_executable_properties ===
 
   enum class PipelineExecutableStatisticFormatKHR
@@ -7145,6 +7151,17 @@ namespace VULKAN_HPP_NAMESPACE
     eD3D12 = VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT
   };
 
+  //=== VK_KHR_line_rasterization ===
+
+  enum class LineRasterizationModeKHR
+  {
+    eDefault           = VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR,
+    eRectangular       = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR,
+    eBresenham         = VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR,
+    eRectangularSmooth = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR
+  };
+  using LineRasterizationModeEXT = LineRasterizationModeKHR;
+
   //=== VK_KHR_calibrated_timestamps ===
 
   enum class TimeDomainKHR
@@ -7192,11 +7209,11 @@ namespace VULKAN_HPP_NAMESPACE
   template <>
   struct IndexTypeValue<uint8_t>
   {
-    static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint8EXT;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint8KHR;
   };
 
   template <>
-  struct CppType<IndexType, IndexType::eUint8EXT>
+  struct CppType<IndexType, IndexType::eUint8KHR>
   {
     using Type = uint8_t;
   };
diff --git a/include/vulkan/vulkan_extension_inspection.hpp b/include/vulkan/vulkan_extension_inspection.hpp
index 80cadba..100b141 100644
--- a/include/vulkan/vulkan_extension_inspection.hpp
+++ b/include/vulkan/vulkan_extension_inspection.hpp
@@ -248,7 +248,9 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_KHR_fragment_shading_rate",
       "VK_AMD_shader_core_properties2",
       "VK_AMD_device_coherent_memory",
+      "VK_KHR_dynamic_rendering_local_read",
       "VK_EXT_shader_image_atomic_int64",
+      "VK_KHR_shader_quad_control",
       "VK_KHR_spirv_1_4",
       "VK_EXT_memory_budget",
       "VK_EXT_memory_priority",
@@ -368,6 +370,7 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_EXT_pageable_device_local_memory",
       "VK_KHR_maintenance4",
       "VK_ARM_shader_core_properties",
+      "VK_KHR_shader_subgroup_rotate",
       "VK_ARM_scheduling_controls",
       "VK_EXT_image_sliced_view_of_3d",
       "VK_VALVE_descriptor_set_host_mapping",
@@ -379,6 +382,7 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_NV_memory_decompression",
       "VK_NV_device_generated_commands_compute",
       "VK_NV_linear_color_attachment",
+      "VK_KHR_shader_maximal_reconvergence",
       "VK_EXT_image_compression_control_swapchain",
       "VK_QCOM_image_processing",
       "VK_EXT_nested_command_buffer",
@@ -416,11 +420,16 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_QCOM_filter_cubic_clamp",
       "VK_EXT_attachment_feedback_loop_dynamic_state",
       "VK_KHR_vertex_attribute_divisor",
+      "VK_KHR_load_store_op_none",
+      "VK_KHR_shader_float_controls2",
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
       "VK_QNX_external_memory_screen_buffer",
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
       "VK_MSFT_layered_driver",
+      "VK_KHR_index_type_uint8",
+      "VK_KHR_line_rasterization",
       "VK_KHR_calibrated_timestamps",
+      "VK_KHR_shader_expect_assume",
       "VK_KHR_maintenance6",
       "VK_NV_descriptor_pool_overallocation"
     };
@@ -1231,12 +1240,23 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_get_physical_device_properties2",
             } } } } },
+      { "VK_KHR_dynamic_rendering_local_read",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_dynamic_rendering",
+            } } } } },
       { "VK_EXT_shader_image_atomic_int64",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_shader_quad_control",
+        { { "VK_VERSION_1_1",
+            { {
+              "VK_KHR_vulkan_memory_model",
+              "VK_KHR_shader_maximal_reconvergence",
+            } } } } },
       { "VK_KHR_spirv_1_4",
         { { "VK_VERSION_1_1",
             { {
@@ -1845,6 +1865,7 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_surface",
             } } } } },
+      { "VK_KHR_shader_maximal_reconvergence", { { "VK_VERSION_1_1", { {} } } } },
       { "VK_EXT_image_compression_control_swapchain",
         { { "VK_VERSION_1_0",
             { {
@@ -2031,6 +2052,11 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_shader_float_controls2",
+        { { "VK_VERSION_1_1",
+            { {
+              "VK_KHR_shader_float_controls",
+            } } } } },
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
       { "VK_QNX_external_memory_screen_buffer",
         { { "VK_VERSION_1_0",
@@ -2049,12 +2075,29 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_get_physical_device_properties2",
             } } } } },
+      { "VK_KHR_index_type_uint8",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_line_rasterization",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_calibrated_timestamps",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_shader_expect_assume",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } } } },
       { "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } },
       { "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } }
     };
@@ -2163,6 +2206,7 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_KHR_uniform_buffer_standard_layout", "VK_VERSION_1_2" },
       { "VK_KHR_buffer_device_address", "VK_VERSION_1_2" },
       { "VK_EXT_host_query_reset", "VK_VERSION_1_2" },
+      { "VK_EXT_index_type_uint8", "VK_KHR_index_type_uint8" },
       { "VK_EXT_extended_dynamic_state", "VK_VERSION_1_3" },
       { "VK_EXT_shader_demote_to_helper_invocation", "VK_VERSION_1_3" },
       { "VK_KHR_shader_integer_dot_product", "VK_VERSION_1_3" },
@@ -2181,6 +2225,7 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_KHR_format_feature_flags2", "VK_VERSION_1_3" },
       { "VK_EXT_extended_dynamic_state2", "VK_VERSION_1_3" },
       { "VK_EXT_global_priority_query", "VK_KHR_global_priority" },
+      { "VK_EXT_load_store_op_none", "VK_KHR_load_store_op_none" },
       { "VK_KHR_maintenance4", "VK_VERSION_1_3" }
     };
     return promotedExtensions;
@@ -2518,6 +2563,10 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_VERSION_1_2";
     }
+    if ( extension == "VK_EXT_index_type_uint8" )
+    {
+      return "VK_KHR_index_type_uint8";
+    }
     if ( extension == "VK_EXT_extended_dynamic_state" )
     {
       return "VK_VERSION_1_3";
@@ -2590,6 +2639,10 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_KHR_global_priority";
     }
+    if ( extension == "VK_EXT_load_store_op_none" )
+    {
+      return "VK_KHR_load_store_op_none";
+    }
     if ( extension == "VK_KHR_maintenance4" )
     {
       return "VK_VERSION_1_3";
@@ -2708,7 +2761,8 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_GOOGLE_hlsl_functionality1" ) || ( extension == "VK_GOOGLE_decorate_string" ) ||
            ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_fragment_shading_rate" ) ||
            ( extension == "VK_AMD_shader_core_properties2" ) || ( extension == "VK_AMD_device_coherent_memory" ) ||
-           ( extension == "VK_EXT_shader_image_atomic_int64" ) || ( extension == "VK_KHR_spirv_1_4" ) || ( extension == "VK_EXT_memory_budget" ) ||
+           ( extension == "VK_KHR_dynamic_rendering_local_read" ) || ( extension == "VK_EXT_shader_image_atomic_int64" ) ||
+           ( extension == "VK_KHR_shader_quad_control" ) || ( extension == "VK_KHR_spirv_1_4" ) || ( extension == "VK_EXT_memory_budget" ) ||
            ( extension == "VK_EXT_memory_priority" ) || ( extension == "VK_NV_dedicated_allocation_image_aliasing" ) ||
            ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || ( extension == "VK_EXT_buffer_device_address" ) ||
            ( extension == "VK_EXT_tooling_info" ) || ( extension == "VK_EXT_separate_stencil_usage" ) || ( extension == "VK_KHR_present_wait" ) ||
@@ -2770,17 +2824,18 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
         || ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_HUAWEI_cluster_culling_shader" ) ||
            ( extension == "VK_EXT_border_color_swizzle" ) || ( extension == "VK_EXT_pageable_device_local_memory" ) || ( extension == "VK_KHR_maintenance4" ) ||
-           ( extension == "VK_ARM_shader_core_properties" ) || ( extension == "VK_ARM_scheduling_controls" ) ||
-           ( extension == "VK_EXT_image_sliced_view_of_3d" ) || ( extension == "VK_VALVE_descriptor_set_host_mapping" ) ||
-           ( extension == "VK_EXT_depth_clamp_zero_one" ) || ( extension == "VK_EXT_non_seamless_cube_map" ) || ( extension == "VK_ARM_render_pass_striped" ) ||
+           ( extension == "VK_ARM_shader_core_properties" ) || ( extension == "VK_KHR_shader_subgroup_rotate" ) ||
+           ( extension == "VK_ARM_scheduling_controls" ) || ( extension == "VK_EXT_image_sliced_view_of_3d" ) ||
+           ( extension == "VK_VALVE_descriptor_set_host_mapping" ) || ( extension == "VK_EXT_depth_clamp_zero_one" ) ||
+           ( 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_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_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*/
@@ -2793,11 +2848,13 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( 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_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" )
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
         || ( extension == "VK_QNX_external_memory_screen_buffer" )
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-        || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_maintenance6" ) ||
+        || ( 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" );
   }
 
@@ -2896,15 +2953,16 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_EXT_scalar_block_layout" ) || ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_spirv_1_4" ) ||
            ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || ( extension == "VK_EXT_tooling_info" ) ||
            ( extension == "VK_EXT_separate_stencil_usage" ) || ( extension == "VK_KHR_uniform_buffer_standard_layout" ) ||
-           ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_host_query_reset" ) || ( extension == "VK_EXT_extended_dynamic_state" ) ||
-           ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || ( extension == "VK_KHR_shader_integer_dot_product" ) ||
-           ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_EXT_private_data" ) ||
+           ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_host_query_reset" ) || ( extension == "VK_EXT_index_type_uint8" ) ||
+           ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
+           ( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) ||
+           ( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_EXT_private_data" ) ||
            ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) ||
            ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) ||
            ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) ||
            ( extension == "VK_ARM_rasterization_order_attachment_access" ) || ( extension == "VK_VALVE_mutable_descriptor_type" ) ||
            ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) ||
-           ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_KHR_maintenance4" );
+           ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" );
   }
 }  // namespace VULKAN_HPP_NAMESPACE
 
diff --git a/include/vulkan/vulkan_funcs.hpp b/include/vulkan/vulkan_funcs.hpp
index c678ac9..3c8d9ae 100644
--- a/include/vulkan/vulkan_funcs.hpp
+++ b/include/vulkan/vulkan_funcs.hpp
@@ -35,6 +35,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d )
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateInstance && "Function <vkCreateInstance> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Instance instance;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -52,6 +55,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d )
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateInstance && "Function <vkCreateInstance> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Instance instance;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -78,6 +84,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE void Instance::destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyInstance && "Function <vkDestroyInstance> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyInstance( m_instance,
                          reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
@@ -99,6 +108,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Instance::enumeratePhysicalDevices( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDevices && "Function <vkEnumeratePhysicalDevices> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator> physicalDevices;
     uint32_t                                                                   physicalDeviceCount;
@@ -124,12 +136,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PhysicalDeviceAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice>::value, int>::type>
+            typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type
                        Instance::enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDevices && "Function <vkEnumeratePhysicalDevices> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator> physicalDevices( physicalDeviceAllocator );
     uint32_t                                                                   physicalDeviceCount;
@@ -167,6 +181,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getFeatures( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures && "Function <vkGetPhysicalDeviceFeatures> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features;
     d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) );
@@ -190,6 +207,9 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties && "Function <vkGetPhysicalDeviceFormatProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::FormatProperties formatProperties;
     d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( &formatProperties ) );
@@ -228,6 +248,9 @@ namespace VULKAN_HPP_NAMESPACE
                                               Dispatch const &                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties && "Function <vkGetPhysicalDeviceImageFormatProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties;
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -258,6 +281,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties && "Function <vkGetPhysicalDeviceProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties;
     d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) );
@@ -282,6 +308,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties && "Function <vkGetPhysicalDeviceQueueFamilyProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties;
     uint32_t                                                                                 queueFamilyPropertyCount;
@@ -298,14 +327,17 @@ namespace VULKAN_HPP_NAMESPACE
     return queueFamilyProperties;
   }
 
-  template <typename QueueFamilyPropertiesAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value, int>::type>
+  template <
+    typename QueueFamilyPropertiesAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
     PhysicalDevice::getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties && "Function <vkGetPhysicalDeviceQueueFamilyProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties( queueFamilyPropertiesAllocator );
     uint32_t                                                                                 queueFamilyPropertyCount;
@@ -337,6 +369,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getMemoryProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties && "Function <vkGetPhysicalDeviceMemoryProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties;
     d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) );
@@ -357,6 +392,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetInstanceProcAddr && "Function <vkGetInstanceProcAddr> requires <VK_VERSION_1_0>" );
+#  endif
 
     PFN_vkVoidFunction result = d.vkGetInstanceProcAddr( m_instance, name.c_str() );
 
@@ -376,6 +414,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceProcAddr && "Function <vkGetDeviceProcAddr> requires <VK_VERSION_1_0>" );
+#  endif
 
     PFN_vkVoidFunction result = d.vkGetDeviceProcAddr( m_device, name.c_str() );
 
@@ -402,6 +443,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDevice && "Function <vkCreateDevice> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Device device;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -422,6 +466,9 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDevice && "Function <vkCreateDevice> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Device device;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -448,6 +495,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE void Device::destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDevice && "Function <vkDestroyDevice> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyDevice( m_device,
                        reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
@@ -471,6 +521,9 @@ namespace VULKAN_HPP_NAMESPACE
                        enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Dispatch const & d )
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumerateInstanceExtensionProperties && "Function <vkEnumerateInstanceExtensionProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator> properties;
     uint32_t                                                                             propertyCount;
@@ -495,16 +548,19 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, properties );
   }
 
-  template <typename ExtensionPropertiesAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type>
+  template <
+    typename ExtensionPropertiesAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
                        enumerateInstanceExtensionProperties( Optional<const std::string>    layerName,
                                                              ExtensionPropertiesAllocator & extensionPropertiesAllocator,
                                                              Dispatch const &               d )
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumerateInstanceExtensionProperties && "Function <vkEnumerateInstanceExtensionProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator> properties( extensionPropertiesAllocator );
     uint32_t                                                                             propertyCount;
@@ -547,6 +603,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumerateDeviceExtensionProperties && "Function <vkEnumerateDeviceExtensionProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator> properties;
     uint32_t                                                                             propertyCount;
@@ -571,16 +630,19 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, properties );
   }
 
-  template <typename ExtensionPropertiesAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type>
+  template <
+    typename ExtensionPropertiesAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
                        PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string>    layerName,
                                                         ExtensionPropertiesAllocator & extensionPropertiesAllocator,
                                                         Dispatch const &               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumerateDeviceExtensionProperties && "Function <vkEnumerateDeviceExtensionProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator> properties( extensionPropertiesAllocator );
     uint32_t                                                                             propertyCount;
@@ -621,6 +683,9 @@ namespace VULKAN_HPP_NAMESPACE
                        enumerateInstanceLayerProperties( Dispatch const & d )
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumerateInstanceLayerProperties && "Function <vkEnumerateInstanceLayerProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator> properties;
     uint32_t                                                                     propertyCount;
@@ -646,12 +711,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename LayerPropertiesAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type>
+            typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
                        enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d )
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumerateInstanceLayerProperties && "Function <vkEnumerateInstanceLayerProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator> properties( layerPropertiesAllocator );
     uint32_t                                                                     propertyCount;
@@ -691,6 +758,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::enumerateDeviceLayerProperties( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumerateDeviceLayerProperties && "Function <vkEnumerateDeviceLayerProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator> properties;
     uint32_t                                                                     propertyCount;
@@ -716,12 +786,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename LayerPropertiesAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type>
+            typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
                        PhysicalDevice::enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumerateDeviceLayerProperties && "Function <vkEnumerateDeviceLayerProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator> properties( layerPropertiesAllocator );
     uint32_t                                                                     propertyCount;
@@ -760,6 +832,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceQueue && "Function <vkGetDeviceQueue> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Queue queue;
     d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &queue ) );
@@ -784,6 +859,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkQueueSubmit && "Function <vkQueueSubmit> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkQueueSubmit( m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo *>( submits.data() ), static_cast<VkFence>( fence ) ) );
@@ -805,6 +883,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Queue::waitIdle( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkQueueWaitIdle && "Function <vkQueueWaitIdle> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkQueueWaitIdle( m_queue ) );
     resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" );
@@ -825,6 +906,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::waitIdle( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDeviceWaitIdle && "Function <vkDeviceWaitIdle> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkDeviceWaitIdle( m_device ) );
     resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" );
@@ -854,6 +938,9 @@ namespace VULKAN_HPP_NAMESPACE
                             Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAllocateMemory && "Function <vkAllocateMemory> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DeviceMemory memory;
     VULKAN_HPP_NAMESPACE::Result       result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -874,6 +961,9 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAllocateMemory && "Function <vkAllocateMemory> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DeviceMemory memory;
     VULKAN_HPP_NAMESPACE::Result       result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -905,6 +995,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkFreeMemory && "Function <vkFreeMemory> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkFreeMemory( m_device,
                     static_cast<VkDeviceMemory>( memory ),
@@ -928,6 +1021,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkFreeMemory && "Function <vkFreeMemory> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkFreeMemory( m_device,
                     static_cast<VkDeviceMemory>( memory ),
@@ -961,6 +1057,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                    Dispatch const &                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkMapMemory && "Function <vkMapMemory> requires <VK_VERSION_1_0>" );
+#  endif
 
     void *                       pData;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkMapMemory( m_device,
@@ -998,6 +1097,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                                                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkFlushMappedMemoryRanges && "Function <vkFlushMappedMemoryRanges> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
@@ -1024,6 +1126,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                                                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkInvalidateMappedMemoryRanges && "Function <vkInvalidateMappedMemoryRanges> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
@@ -1048,6 +1153,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryCommitment && "Function <vkGetDeviceMemoryCommitment> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes;
     d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) );
@@ -1073,6 +1181,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBindBufferMemory && "Function <vkBindBufferMemory> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
@@ -1099,6 +1210,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBindImageMemory && "Function <vkBindImageMemory> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
@@ -1123,6 +1237,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements && "Function <vkGetBufferMemoryRequirements> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
     d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
@@ -1146,6 +1263,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Device::getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements && "Function <vkGetImageMemoryRequirements> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
     d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
@@ -1173,6 +1293,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Device::getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements && "Function <vkGetImageSparseMemoryRequirements> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements;
     uint32_t                                                                                                 sparseMemoryRequirementCount;
@@ -1193,14 +1316,18 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename SparseImageMemoryRequirementsAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
                                          Device::getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,
                                               SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
                                               Dispatch const &                         d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements && "Function <vkGetImageSparseMemoryRequirements> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements(
       sparseImageMemoryRequirementsAllocator );
@@ -1253,6 +1380,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const &                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties &&
+                       "Function <vkGetPhysicalDeviceSparseImageFormatProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties;
     uint32_t                                                                                             propertyCount;
@@ -1282,10 +1413,11 @@ namespace VULKAN_HPP_NAMESPACE
     return properties;
   }
 
-  template <typename SparseImageFormatPropertiesAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value, int>::type>
+  template <
+    typename SparseImageFormatPropertiesAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
                                          PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
                                                     VULKAN_HPP_NAMESPACE::ImageType           type,
@@ -1296,6 +1428,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const &                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties &&
+                       "Function <vkGetPhysicalDeviceSparseImageFormatProperties> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties( sparseImageFormatPropertiesAllocator );
     uint32_t                                                                                             propertyCount;
@@ -1343,6 +1479,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkQueueBindSparse && "Function <vkQueueBindSparse> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkQueueBindSparse( m_queue, bindInfo.size(), reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ), static_cast<VkFence>( fence ) ) );
@@ -1371,6 +1510,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateFence && "Function <vkCreateFence> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Fence  fence;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -1389,6 +1531,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateFence && "Function <vkCreateFence> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Fence  fence;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -1420,6 +1565,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyFence && "Function <vkDestroyFence> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyFence( m_device,
                       static_cast<VkFence>( fence ),
@@ -1443,6 +1591,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyFence && "Function <vkDestroyFence> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyFence( m_device,
                       static_cast<VkFence>( fence ),
@@ -1465,6 +1616,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkResetFences && "Function <vkResetFences> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkResetFences( m_device, fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) ) );
@@ -1486,6 +1640,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetFenceStatus && "Function <vkGetFenceStatus> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
     resultCheck(
@@ -1516,6 +1673,9 @@ namespace VULKAN_HPP_NAMESPACE
                            Dispatch const &                                                            d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkWaitForFences && "Function <vkWaitForFences> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkWaitForFences( m_device, fences.size(), reinterpret_cast<const VkFence *>( fences.data() ), static_cast<VkBool32>( waitAll ), timeout ) );
@@ -1547,6 +1707,9 @@ namespace VULKAN_HPP_NAMESPACE
                              Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSemaphore && "Function <vkCreateSemaphore> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Semaphore semaphore;
     VULKAN_HPP_NAMESPACE::Result    result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -1567,6 +1730,9 @@ namespace VULKAN_HPP_NAMESPACE
                                    Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSemaphore && "Function <vkCreateSemaphore> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Semaphore semaphore;
     VULKAN_HPP_NAMESPACE::Result    result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -1598,6 +1764,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroySemaphore && "Function <vkDestroySemaphore> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroySemaphore( m_device,
                           static_cast<VkSemaphore>( semaphore ),
@@ -1621,6 +1790,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroySemaphore && "Function <vkDestroySemaphore> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroySemaphore( m_device,
                           static_cast<VkSemaphore>( semaphore ),
@@ -1647,6 +1819,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateEvent && "Function <vkCreateEvent> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Event  event;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -1665,6 +1840,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateEvent && "Function <vkCreateEvent> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Event  event;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -1696,6 +1874,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyEvent && "Function <vkDestroyEvent> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyEvent( m_device,
                       static_cast<VkEvent>( event ),
@@ -1719,6 +1900,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyEvent && "Function <vkDestroyEvent> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyEvent( m_device,
                       static_cast<VkEvent>( event ),
@@ -1738,6 +1922,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetEventStatus && "Function <vkGetEventStatus> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
     resultCheck(
@@ -1760,6 +1947,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                                    Dispatch const &            d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSetEvent && "Function <vkSetEvent> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
     resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setEvent" );
@@ -1780,6 +1970,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkResetEvent && "Function <vkResetEvent> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
     resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetEvent" );
@@ -1809,6 +2002,9 @@ namespace VULKAN_HPP_NAMESPACE
                              Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateQueryPool && "Function <vkCreateQueryPool> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::QueryPool queryPool;
     VULKAN_HPP_NAMESPACE::Result    result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -1829,6 +2025,9 @@ namespace VULKAN_HPP_NAMESPACE
                                    Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateQueryPool && "Function <vkCreateQueryPool> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::QueryPool queryPool;
     VULKAN_HPP_NAMESPACE::Result    result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -1860,6 +2059,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyQueryPool && "Function <vkDestroyQueryPool> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyQueryPool( m_device,
                           static_cast<VkQueryPool>( queryPool ),
@@ -1883,6 +2085,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyQueryPool && "Function <vkDestroyQueryPool> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyQueryPool( m_device,
                           static_cast<VkQueryPool>( queryPool ),
@@ -1923,6 +2128,9 @@ namespace VULKAN_HPP_NAMESPACE
                                  Dispatch const &                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetQueryPoolResults && "Function <vkGetQueryPoolResults> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
     std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
@@ -1950,6 +2158,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                            Dispatch const &                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetQueryPoolResults && "Function <vkGetQueryPoolResults> requires <VK_VERSION_1_0>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetQueryPoolResults( m_device,
@@ -1986,6 +2197,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateBuffer && "Function <vkCreateBuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Buffer buffer;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2004,6 +2218,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateBuffer && "Function <vkCreateBuffer> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Buffer buffer;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2035,6 +2252,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyBuffer && "Function <vkDestroyBuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyBuffer( m_device,
                        static_cast<VkBuffer>( buffer ),
@@ -2058,6 +2278,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyBuffer && "Function <vkDestroyBuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyBuffer( m_device,
                        static_cast<VkBuffer>( buffer ),
@@ -2086,6 +2309,9 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateBufferView && "Function <vkCreateBufferView> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::BufferView view;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2106,6 +2332,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateBufferView && "Function <vkCreateBufferView> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::BufferView view;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2137,6 +2366,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyBufferView && "Function <vkDestroyBufferView> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyBufferView( m_device,
                            static_cast<VkBufferView>( bufferView ),
@@ -2160,6 +2392,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyBufferView && "Function <vkDestroyBufferView> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyBufferView( m_device,
                            static_cast<VkBufferView>( bufferView ),
@@ -2186,6 +2421,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateImage && "Function <vkCreateImage> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Image  image;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2204,6 +2442,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateImage && "Function <vkCreateImage> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Image  image;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2235,6 +2476,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyImage && "Function <vkDestroyImage> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyImage( m_device,
                       static_cast<VkImage>( image ),
@@ -2258,6 +2502,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyImage && "Function <vkDestroyImage> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyImage( m_device,
                       static_cast<VkImage>( image ),
@@ -2284,6 +2531,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageSubresourceLayout && "Function <vkGetImageSubresourceLayout> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SubresourceLayout layout;
     d.vkGetImageSubresourceLayout( m_device,
@@ -2316,6 +2566,9 @@ namespace VULKAN_HPP_NAMESPACE
                              Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateImageView && "Function <vkCreateImageView> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ImageView view;
     VULKAN_HPP_NAMESPACE::Result    result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2336,6 +2589,9 @@ namespace VULKAN_HPP_NAMESPACE
                                    Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateImageView && "Function <vkCreateImageView> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::ImageView view;
     VULKAN_HPP_NAMESPACE::Result    result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2367,6 +2623,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyImageView && "Function <vkDestroyImageView> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyImageView( m_device,
                           static_cast<VkImageView>( imageView ),
@@ -2390,6 +2649,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyImageView && "Function <vkDestroyImageView> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyImageView( m_device,
                           static_cast<VkImageView>( imageView ),
@@ -2418,6 +2680,9 @@ namespace VULKAN_HPP_NAMESPACE
                                 Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateShaderModule && "Function <vkCreateShaderModule> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ShaderModule shaderModule;
     VULKAN_HPP_NAMESPACE::Result       result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2438,6 +2703,9 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateShaderModule && "Function <vkCreateShaderModule> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::ShaderModule shaderModule;
     VULKAN_HPP_NAMESPACE::Result       result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2469,6 +2737,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyShaderModule && "Function <vkDestroyShaderModule> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyShaderModule( m_device,
                              static_cast<VkShaderModule>( shaderModule ),
@@ -2492,6 +2763,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyShaderModule && "Function <vkDestroyShaderModule> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyShaderModule( m_device,
                              static_cast<VkShaderModule>( shaderModule ),
@@ -2520,6 +2794,9 @@ namespace VULKAN_HPP_NAMESPACE
                                  Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreatePipelineCache && "Function <vkCreatePipelineCache> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache;
     VULKAN_HPP_NAMESPACE::Result        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2540,6 +2817,9 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreatePipelineCache && "Function <vkCreatePipelineCache> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache;
     VULKAN_HPP_NAMESPACE::Result        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -2571,6 +2851,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                        Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyPipelineCache && "Function <vkDestroyPipelineCache> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyPipelineCache( m_device,
                               static_cast<VkPipelineCache>( pipelineCache ),
@@ -2594,6 +2877,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyPipelineCache && "Function <vkDestroyPipelineCache> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyPipelineCache( m_device,
                               static_cast<VkPipelineCache>( pipelineCache ),
@@ -2617,6 +2903,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelineCacheData && "Function <vkGetPipelineCacheData> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<uint8_t, Uint8_tAllocator> data;
     size_t                                 dataSize;
@@ -2643,12 +2932,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Uint8_tAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type>
+            typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
     Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelineCacheData && "Function <vkGetPipelineCacheData> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator );
     size_t                                 dataSize;
@@ -2693,6 +2984,9 @@ namespace VULKAN_HPP_NAMESPACE
                                  Dispatch const &                                                                    d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkMergePipelineCaches && "Function <vkMergePipelineCaches> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkMergePipelineCaches(
       m_device, static_cast<VkPipelineCache>( dstCache ), srcCaches.size(), reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) );
@@ -2728,6 +3022,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines(
@@ -2746,8 +3043,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PipelineAllocator,
             typename Dispatch,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type>
+            typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
                                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
@@ -2756,6 +3052,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
     VULKAN_HPP_NAMESPACE::Result                                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines(
@@ -2780,6 +3079,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Pipeline pipeline;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines(
@@ -2805,6 +3107,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines(
@@ -2828,10 +3133,10 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
   }
 
-  template <typename Dispatch,
-            typename PipelineAllocator,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type>
+  template <
+    typename Dispatch,
+    typename PipelineAllocator,
+    typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
                                          Device::createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
                                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
@@ -2840,6 +3145,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines(
@@ -2871,6 +3179,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Pipeline pipeline;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines(
@@ -2917,6 +3228,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines(
@@ -2935,8 +3249,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PipelineAllocator,
             typename Dispatch,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type>
+            typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
                                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
@@ -2945,6 +3258,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
     VULKAN_HPP_NAMESPACE::Result                                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines(
@@ -2969,6 +3285,9 @@ namespace VULKAN_HPP_NAMESPACE
                                    Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Pipeline pipeline;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines(
@@ -2994,6 +3313,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines(
@@ -3017,10 +3339,10 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
   }
 
-  template <typename Dispatch,
-            typename PipelineAllocator,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type>
+  template <
+    typename Dispatch,
+    typename PipelineAllocator,
+    typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
                                          Device::createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
@@ -3029,6 +3351,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines(
@@ -3060,6 +3385,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Pipeline pipeline;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines(
@@ -3096,6 +3424,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyPipeline && "Function <vkDestroyPipeline> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyPipeline( m_device,
                          static_cast<VkPipeline>( pipeline ),
@@ -3119,6 +3450,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyPipeline && "Function <vkDestroyPipeline> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyPipeline( m_device,
                          static_cast<VkPipeline>( pipeline ),
@@ -3147,6 +3481,9 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreatePipelineLayout && "Function <vkCreatePipelineLayout> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout;
     VULKAN_HPP_NAMESPACE::Result         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -3167,6 +3504,9 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreatePipelineLayout && "Function <vkCreatePipelineLayout> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout;
     VULKAN_HPP_NAMESPACE::Result         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -3198,6 +3538,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyPipelineLayout && "Function <vkDestroyPipelineLayout> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyPipelineLayout( m_device,
                                static_cast<VkPipelineLayout>( pipelineLayout ),
@@ -3221,6 +3564,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyPipelineLayout && "Function <vkDestroyPipelineLayout> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyPipelineLayout( m_device,
                                static_cast<VkPipelineLayout>( pipelineLayout ),
@@ -3247,6 +3593,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSampler && "Function <vkCreateSampler> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Sampler sampler;
     VULKAN_HPP_NAMESPACE::Result  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -3265,6 +3614,9 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSampler && "Function <vkCreateSampler> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Sampler sampler;
     VULKAN_HPP_NAMESPACE::Result  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -3296,6 +3648,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroySampler && "Function <vkDestroySampler> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroySampler( m_device,
                         static_cast<VkSampler>( sampler ),
@@ -3319,6 +3674,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroySampler && "Function <vkDestroySampler> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroySampler( m_device,
                         static_cast<VkSampler>( sampler ),
@@ -3347,6 +3705,9 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                                            d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDescriptorSetLayout && "Function <vkCreateDescriptorSetLayout> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout;
     VULKAN_HPP_NAMESPACE::Result              result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorSetLayout(
@@ -3367,6 +3728,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                                            d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDescriptorSetLayout && "Function <vkCreateDescriptorSetLayout> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout;
     VULKAN_HPP_NAMESPACE::Result              result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorSetLayout(
@@ -3399,6 +3763,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                              Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDescriptorSetLayout && "Function <vkDestroyDescriptorSetLayout> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyDescriptorSetLayout(
       m_device,
@@ -3424,6 +3791,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDescriptorSetLayout && "Function <vkDestroyDescriptorSetLayout> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyDescriptorSetLayout(
       m_device,
@@ -3453,6 +3823,9 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDescriptorPool && "Function <vkCreateDescriptorPool> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool;
     VULKAN_HPP_NAMESPACE::Result         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -3473,6 +3846,9 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDescriptorPool && "Function <vkCreateDescriptorPool> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool;
     VULKAN_HPP_NAMESPACE::Result         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -3504,6 +3880,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDescriptorPool && "Function <vkDestroyDescriptorPool> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyDescriptorPool( m_device,
                                static_cast<VkDescriptorPool>( descriptorPool ),
@@ -3527,6 +3906,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDescriptorPool && "Function <vkDestroyDescriptorPool> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyDescriptorPool( m_device,
                                static_cast<VkDescriptorPool>( descriptorPool ),
@@ -3551,6 +3933,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkResetDescriptorPool && "Function <vkResetDescriptorPool> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) );
   }
@@ -3572,6 +3957,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount );
     VULKAN_HPP_NAMESPACE::Result                                             result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateDescriptorSets(
@@ -3583,14 +3971,16 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename DescriptorSetAllocator,
             typename Dispatch,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet>::value, int>::type>
+            typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
                        Device::allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
                                     DescriptorSetAllocator &                                descriptorSetAllocator,
                                     Dispatch const &                                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount, descriptorSetAllocator );
     VULKAN_HPP_NAMESPACE::Result                                             result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateDescriptorSets(
@@ -3607,6 +3997,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
     VULKAN_HPP_NAMESPACE::Result                     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateDescriptorSets(
@@ -3622,10 +4015,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, std::move( uniqueDescriptorSets ) );
   }
 
-  template <typename Dispatch,
-            typename DescriptorSetAllocator,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>::value, int>::type>
+  template <
+    typename Dispatch,
+    typename DescriptorSetAllocator,
+    typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
     Device::allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
@@ -3633,6 +4027,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
     VULKAN_HPP_NAMESPACE::Result                     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateDescriptorSets(
@@ -3668,6 +4065,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function <vkFreeDescriptorSets> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkFreeDescriptorSets(
       m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) );
@@ -3692,6 +4092,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                                                    d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function <vkFreeDescriptorSets> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkFreeDescriptorSets(
       m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) );
@@ -3721,6 +4124,9 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const &                                                                         d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSets && "Function <vkUpdateDescriptorSets> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkUpdateDescriptorSets( m_device,
                               descriptorWrites.size(),
@@ -3751,6 +4157,9 @@ namespace VULKAN_HPP_NAMESPACE
                                Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateFramebuffer && "Function <vkCreateFramebuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Framebuffer framebuffer;
     VULKAN_HPP_NAMESPACE::Result      result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -3771,6 +4180,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateFramebuffer && "Function <vkCreateFramebuffer> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Framebuffer framebuffer;
     VULKAN_HPP_NAMESPACE::Result      result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -3802,6 +4214,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyFramebuffer && "Function <vkDestroyFramebuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyFramebuffer( m_device,
                             static_cast<VkFramebuffer>( framebuffer ),
@@ -3825,6 +4240,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyFramebuffer && "Function <vkDestroyFramebuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyFramebuffer( m_device,
                             static_cast<VkFramebuffer>( framebuffer ),
@@ -3853,6 +4271,9 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRenderPass && "Function <vkCreateRenderPass> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -3873,6 +4294,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRenderPass && "Function <vkCreateRenderPass> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -3904,6 +4328,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyRenderPass && "Function <vkDestroyRenderPass> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyRenderPass( m_device,
                            static_cast<VkRenderPass>( renderPass ),
@@ -3927,6 +4354,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyRenderPass && "Function <vkDestroyRenderPass> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyRenderPass( m_device,
                            static_cast<VkRenderPass>( renderPass ),
@@ -3949,6 +4379,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetRenderAreaGranularity && "Function <vkGetRenderAreaGranularity> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Extent2D granularity;
     d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D *>( &granularity ) );
@@ -3978,6 +4411,9 @@ namespace VULKAN_HPP_NAMESPACE
                                Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateCommandPool && "Function <vkCreateCommandPool> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::CommandPool commandPool;
     VULKAN_HPP_NAMESPACE::Result      result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -3998,6 +4434,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateCommandPool && "Function <vkCreateCommandPool> requires <VK_VERSION_1_0>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::CommandPool commandPool;
     VULKAN_HPP_NAMESPACE::Result      result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -4029,6 +4468,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyCommandPool && "Function <vkDestroyCommandPool> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyCommandPool( m_device,
                             static_cast<VkCommandPool>( commandPool ),
@@ -4052,6 +4494,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyCommandPool && "Function <vkDestroyCommandPool> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkDestroyCommandPool( m_device,
                             static_cast<VkCommandPool>( commandPool ),
@@ -4074,6 +4519,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkResetCommandPool && "Function <vkResetCommandPool> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
@@ -4099,6 +4547,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount );
     VULKAN_HPP_NAMESPACE::Result                                             result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateCommandBuffers(
@@ -4110,14 +4561,16 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename CommandBufferAllocator,
             typename Dispatch,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer>::value, int>::type>
+            typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
                        Device::allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
                                     CommandBufferAllocator &                                commandBufferAllocator,
                                     Dispatch const &                                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount, commandBufferAllocator );
     VULKAN_HPP_NAMESPACE::Result                                             result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateCommandBuffers(
@@ -4134,6 +4587,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
     VULKAN_HPP_NAMESPACE::Result                     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateCommandBuffers(
@@ -4149,10 +4605,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, std::move( uniqueCommandBuffers ) );
   }
 
-  template <typename Dispatch,
-            typename CommandBufferAllocator,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>::value, int>::type>
+  template <
+    typename Dispatch,
+    typename CommandBufferAllocator,
+    typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
     Device::allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
@@ -4160,6 +4617,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
     VULKAN_HPP_NAMESPACE::Result                     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateCommandBuffers(
@@ -4195,6 +4655,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkFreeCommandBuffers && "Function <vkFreeCommandBuffers> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkFreeCommandBuffers(
       m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
@@ -4219,6 +4682,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                                                    d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkFreeCommandBuffers && "Function <vkFreeCommandBuffers> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkFreeCommandBuffers(
       m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
@@ -4239,6 +4705,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           CommandBuffer::begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBeginCommandBuffer && "Function <vkBeginCommandBuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) ) );
@@ -4260,6 +4729,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type CommandBuffer::end( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEndCommandBuffer && "Function <vkEndCommandBuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
     resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" );
@@ -4281,6 +4753,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE typename ResultValueType<void>::type CommandBuffer::reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkResetCommandBuffer && "Function <vkResetCommandBuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
@@ -4316,6 +4791,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetViewport && "Function <vkCmdSetViewport> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
   }
@@ -4338,6 +4816,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const &                                                             d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetScissor && "Function <vkCmdSetScissor> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
   }
@@ -4427,6 +4908,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets && "Function <vkCmdBindDescriptorSets> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdBindDescriptorSets( m_commandBuffer,
                                static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
@@ -4469,6 +4953,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers && "Function <vkCmdBindVertexBuffers> requires <VK_VERSION_1_0>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
 #  else
@@ -4568,6 +5055,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer && "Function <vkCmdCopyBuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdCopyBuffer( m_commandBuffer,
                        static_cast<VkBuffer>( srcBuffer ),
@@ -4606,6 +5096,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                                                d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyImage && "Function <vkCmdCopyImage> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdCopyImage( m_commandBuffer,
                       static_cast<VkImage>( srcImage ),
@@ -4649,6 +5142,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                                                d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBlitImage && "Function <vkCmdBlitImage> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdBlitImage( m_commandBuffer,
                       static_cast<VkImage>( srcImage ),
@@ -4687,6 +5183,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage && "Function <vkCmdCopyBufferToImage> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdCopyBufferToImage( m_commandBuffer,
                               static_cast<VkBuffer>( srcBuffer ),
@@ -4723,6 +5222,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer && "Function <vkCmdCopyImageToBuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdCopyImageToBuffer( m_commandBuffer,
                               static_cast<VkImage>( srcImage ),
@@ -4753,6 +5255,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                                         d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdUpdateBuffer && "Function <vkCmdUpdateBuffer> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdUpdateBuffer( m_commandBuffer,
                          static_cast<VkBuffer>( dstBuffer ),
@@ -4799,6 +5304,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdClearColorImage && "Function <vkCmdClearColorImage> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdClearColorImage( m_commandBuffer,
                             static_cast<VkImage>( image ),
@@ -4836,6 +5344,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdClearDepthStencilImage && "Function <vkCmdClearDepthStencilImage> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdClearDepthStencilImage( m_commandBuffer,
                                    static_cast<VkImage>( image ),
@@ -4868,6 +5379,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdClearAttachments && "Function <vkCmdClearAttachments> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdClearAttachments( m_commandBuffer,
                              attachments.size(),
@@ -4906,6 +5420,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdResolveImage && "Function <vkCmdResolveImage> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdResolveImage( m_commandBuffer,
                          static_cast<VkImage>( srcImage ),
@@ -4974,6 +5491,9 @@ namespace VULKAN_HPP_NAMESPACE
                                Dispatch const &                                                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdWaitEvents && "Function <vkCmdWaitEvents> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdWaitEvents( m_commandBuffer,
                        events.size(),
@@ -5026,6 +5546,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier && "Function <vkCmdPipelineBarrier> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdPipelineBarrier( m_commandBuffer,
                             static_cast<VkPipelineStageFlags>( srcStageMask ),
@@ -5119,6 +5642,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                        Dispatch const &                                           d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdPushConstants && "Function <vkCmdPushConstants> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdPushConstants( m_commandBuffer,
                           static_cast<VkPipelineLayout>( layout ),
@@ -5145,6 +5671,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                          Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass && "Function <vkCmdBeginRenderPass> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), static_cast<VkSubpassContents>( contents ) );
   }
@@ -5179,6 +5708,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdExecuteCommands && "Function <vkCmdExecuteCommands> requires <VK_VERSION_1_0>" );
+#  endif
 
     d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
   }
@@ -5198,6 +5730,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d )
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumerateInstanceVersion && "Function <vkEnumerateInstanceVersion> requires <VK_VERSION_1_1>" );
+#  endif
 
     uint32_t                     apiVersion;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumerateInstanceVersion( &apiVersion ) );
@@ -5222,6 +5757,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBindBufferMemory2 && "Function <vkBindBufferMemory2> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkBindBufferMemory2( m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
@@ -5246,6 +5784,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBindImageMemory2 && "Function <vkBindImageMemory2> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkBindImageMemory2( m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
@@ -5273,6 +5814,10 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPeerMemoryFeatures &&
+                       "Function <vkGetDeviceGroupPeerMemoryFeatures> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
     d.vkGetDeviceGroupPeerMemoryFeatures(
@@ -5320,6 +5865,10 @@ namespace VULKAN_HPP_NAMESPACE
     Instance::enumeratePhysicalDeviceGroups( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroups &&
+                       "Function <vkEnumeratePhysicalDeviceGroups> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties;
     uint32_t                                                                                                 physicalDeviceGroupCount;
@@ -5345,13 +5894,18 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PhysicalDeviceGroupPropertiesAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
     Instance::enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroups &&
+                       "Function <vkEnumeratePhysicalDeviceGroups> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties(
       physicalDeviceGroupPropertiesAllocator );
@@ -5393,6 +5947,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2 &&
+                       "Function <vkGetImageMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
     d.vkGetImageMemoryRequirements2(
@@ -5406,6 +5964,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2 &&
+                       "Function <vkGetImageMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 &      memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
@@ -5432,6 +5994,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2 &&
+                       "Function <vkGetBufferMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
     d.vkGetBufferMemoryRequirements2(
@@ -5445,6 +6011,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2 &&
+                       "Function <vkGetBufferMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 &      memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
@@ -5474,6 +6044,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2 &&
+                       "Function <vkGetImageSparseMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
     uint32_t                                                                                                   sparseMemoryRequirementCount;
@@ -5495,14 +6069,19 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename SparseImageMemoryRequirements2Allocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
                                          Device::getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
                                                SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
                                                Dispatch const &                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2 &&
+                       "Function <vkGetImageSparseMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
       sparseImageMemoryRequirements2Allocator );
@@ -5537,6 +6116,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2 &&
+                       "Function <vkGetPhysicalDeviceFeatures2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
     d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
@@ -5549,6 +6132,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2 &&
+                       "Function <vkGetPhysicalDeviceFeatures2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 &  features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
@@ -5572,6 +6159,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2 &&
+                       "Function <vkGetPhysicalDeviceProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
     d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
@@ -5584,6 +6175,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2 &&
+                       "Function <vkGetPhysicalDeviceProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>  structureChain;
     VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
@@ -5608,6 +6203,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2 &&
+                       "Function <vkGetPhysicalDeviceFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
     d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
@@ -5620,6 +6219,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2 &&
+                       "Function <vkGetPhysicalDeviceFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::FormatProperties2 &        formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
@@ -5647,6 +6250,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2 &&
+                       "Function <vkGetPhysicalDeviceImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -5663,6 +6270,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2 &&
+                       "Function <vkGetPhysicalDeviceImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     StructureChain<X, Y, Z...>                     structureChain;
     VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
@@ -5692,6 +6303,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 &&
+                       "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties;
     uint32_t                                                                                   queueFamilyPropertyCount;
@@ -5708,14 +6323,18 @@ namespace VULKAN_HPP_NAMESPACE
     return queueFamilyProperties;
   }
 
-  template <typename QueueFamilyProperties2Allocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value, int>::type>
+  template <
+    typename QueueFamilyProperties2Allocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
     PhysicalDevice::getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 &&
+                       "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties( queueFamilyProperties2Allocator );
     uint32_t                                                                                   queueFamilyPropertyCount;
@@ -5737,6 +6356,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 &&
+                       "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<StructureChain, StructureChainAllocator>      structureChains;
     std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
@@ -5766,12 +6389,15 @@ namespace VULKAN_HPP_NAMESPACE
   template <typename StructureChain,
             typename StructureChainAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type>
+            typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
     PhysicalDevice::getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 &&
+                       "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<StructureChain, StructureChainAllocator>      structureChains( structureChainAllocator );
     std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
@@ -5813,6 +6439,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2 &&
+                       "Function <vkGetPhysicalDeviceMemoryProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
     d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
@@ -5825,6 +6455,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2 &&
+                       "Function <vkGetPhysicalDeviceMemoryProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>        structureChain;
     VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
@@ -5854,6 +6488,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2 &&
+                       "Function <vkGetPhysicalDeviceSparseImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
     uint32_t                                                                                               propertyCount;
@@ -5873,16 +6511,21 @@ namespace VULKAN_HPP_NAMESPACE
     return properties;
   }
 
-  template <typename SparseImageFormatProperties2Allocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value, int>::type>
+  template <
+    typename SparseImageFormatProperties2Allocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
     PhysicalDevice::getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
                                                      SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,
                                                      Dispatch const &                                                   d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2 &&
+                       "Function <vkGetPhysicalDeviceSparseImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties( sparseImageFormatProperties2Allocator );
     uint32_t                                                                                               propertyCount;
@@ -5927,6 +6570,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceQueue2 && "Function <vkGetDeviceQueue2> requires <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Queue queue;
     d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ), reinterpret_cast<VkQueue *>( &queue ) );
@@ -5957,6 +6603,10 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversion &&
+                       "Function <vkCreateSamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSamplerYcbcrConversion(
@@ -5977,6 +6627,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversion &&
+                       "Function <vkCreateSamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSamplerYcbcrConversion(
@@ -6009,6 +6663,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                 Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversion &&
+                       "Function <vkDestroySamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
+#  endif
 
     d.vkDestroySamplerYcbcrConversion(
       m_device,
@@ -6034,6 +6692,10 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversion &&
+                       "Function <vkDestroySamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
+#  endif
 
     d.vkDestroySamplerYcbcrConversion(
       m_device,
@@ -6064,6 +6726,10 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplate &&
+                       "Function <vkCreateDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate;
     VULKAN_HPP_NAMESPACE::Result                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorUpdateTemplate(
@@ -6084,6 +6750,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplate &&
+                       "Function <vkCreateDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate;
     VULKAN_HPP_NAMESPACE::Result                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorUpdateTemplate(
@@ -6117,6 +6787,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                   Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplate &&
+                       "Function <vkDestroyDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
+#  endif
 
     d.vkDestroyDescriptorUpdateTemplate(
       m_device,
@@ -6142,6 +6816,10 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplate &&
+                       "Function <vkDestroyDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
+#  endif
 
     d.vkDestroyDescriptorUpdateTemplate(
       m_device,
@@ -6169,6 +6847,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                   Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSetWithTemplate &&
+                       "Function <vkUpdateDescriptorSetWithTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
+#  endif
 
     d.vkUpdateDescriptorSetWithTemplate( m_device,
                                          static_cast<VkDescriptorSet>( descriptorSet ),
@@ -6195,6 +6877,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalBufferProperties &&
+                       "Function <vkGetPhysicalDeviceExternalBufferProperties> requires <VK_KHR_external_memory_capabilities> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
     d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice,
@@ -6223,6 +6909,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                                              d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalFenceProperties &&
+                       "Function <vkGetPhysicalDeviceExternalFenceProperties> requires <VK_KHR_external_fence_capabilities> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
     d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice,
@@ -6252,6 +6942,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalSemaphoreProperties &&
+                       "Function <vkGetPhysicalDeviceExternalSemaphoreProperties> requires <VK_KHR_external_semaphore_capabilities> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
     d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice,
@@ -6279,6 +6973,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupport && "Function <vkGetDescriptorSetLayoutSupport> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
     d.vkGetDescriptorSetLayoutSupport(
@@ -6293,6 +6990,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupport && "Function <vkGetDescriptorSetLayoutSupport> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>   structureChain;
     VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
@@ -6364,6 +7064,9 @@ namespace VULKAN_HPP_NAMESPACE
                                Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRenderPass2 && "Function <vkCreateRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -6384,6 +7087,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRenderPass2 && "Function <vkCreateRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -6416,6 +7122,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                           Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass2 && "Function <vkCmdBeginRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
+#  endif
 
     d.vkCmdBeginRenderPass2(
       m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
@@ -6439,6 +7148,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdNextSubpass2 && "Function <vkCmdNextSubpass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
+#  endif
 
     d.vkCmdNextSubpass2(
       m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
@@ -6459,6 +7171,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdEndRenderPass2 && "Function <vkCmdEndRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
+#  endif
 
     d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
   }
@@ -6487,6 +7202,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                                     Dispatch const &                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetSemaphoreCounterValue && "Function <vkGetSemaphoreCounterValue> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
+#  endif
 
     uint64_t                     value;
     VULKAN_HPP_NAMESPACE::Result result =
@@ -6512,6 +7230,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkWaitSemaphores && "Function <vkWaitSemaphores> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
@@ -6536,6 +7257,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Device::signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSignalSemaphore && "Function <vkSignalSemaphore> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
@@ -6559,6 +7283,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddress &&
+                       "Function <vkGetBufferDeviceAddress> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
+#  endif
 
     VkDeviceAddress result = d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
 
@@ -6580,6 +7308,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                     Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureAddress &&
+                       "Function <vkGetBufferOpaqueCaptureAddress> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
+#  endif
 
     uint64_t result = d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
 
@@ -6601,6 +7333,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryOpaqueCaptureAddress &&
+                       "Function <vkGetDeviceMemoryOpaqueCaptureAddress> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
+#  endif
 
     uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddress( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
 
@@ -6627,6 +7363,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getToolProperties( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolProperties &&
+                       "Function <vkGetPhysicalDeviceToolProperties> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties;
     uint32_t                                                                                               toolCount;
@@ -6650,15 +7390,20 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, toolProperties );
   }
 
-  template <typename PhysicalDeviceToolPropertiesAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value, int>::type>
+  template <
+    typename PhysicalDeviceToolPropertiesAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
     PhysicalDevice::getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolProperties &&
+                       "Function <vkGetPhysicalDeviceToolProperties> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties(
       physicalDeviceToolPropertiesAllocator );
@@ -6705,6 +7450,9 @@ namespace VULKAN_HPP_NAMESPACE
                                    Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlot && "Function <vkCreatePrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot;
     VULKAN_HPP_NAMESPACE::Result          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -6725,6 +7473,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlot && "Function <vkCreatePrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot;
     VULKAN_HPP_NAMESPACE::Result          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -6756,6 +7507,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                          Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlot && "Function <vkDestroyPrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkDestroyPrivateDataSlot(
       m_device,
@@ -6780,6 +7534,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlot && "Function <vkDestroyPrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkDestroyPrivateDataSlot(
       m_device,
@@ -6809,6 +7566,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                  Dispatch const &                      d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSetPrivateData && "Function <vkSetPrivateData> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkSetPrivateData( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) );
@@ -6837,6 +7597,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                           Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPrivateData && "Function <vkGetPrivateData> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
+#  endif
 
     uint64_t data;
     d.vkGetPrivateData( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data );
@@ -6861,6 +7624,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetEvent2 && "Function <vkCmdSetEvent2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdSetEvent2( m_commandBuffer, static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
   }
@@ -6893,6 +7659,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdWaitEvents2 && "Function <vkCmdWaitEvents2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() );
 #  else
@@ -6923,6 +7692,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                           Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier2 && "Function <vkCmdPipelineBarrier2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdPipelineBarrier2( m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
   }
@@ -6954,6 +7726,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkQueueSubmit2 && "Function <vkQueueSubmit2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkQueueSubmit2( m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) ) );
@@ -6977,6 +7752,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const &                              d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer2 && "Function <vkCmdCopyBuffer2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdCopyBuffer2( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>( &copyBufferInfo ) );
   }
@@ -6994,6 +7772,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyImage2 && "Function <vkCmdCopyImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdCopyImage2( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>( &copyImageInfo ) );
   }
@@ -7013,6 +7794,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                             Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage2 && "Function <vkCmdCopyBufferToImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdCopyBufferToImage2( m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>( &copyBufferToImageInfo ) );
   }
@@ -7032,6 +7816,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                             Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer2 && "Function <vkCmdCopyImageToBuffer2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdCopyImageToBuffer2( m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>( &copyImageToBufferInfo ) );
   }
@@ -7049,6 +7836,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBlitImage2 && "Function <vkCmdBlitImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdBlitImage2( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) );
   }
@@ -7068,6 +7858,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                        Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdResolveImage2 && "Function <vkCmdResolveImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdResolveImage2( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) );
   }
@@ -7087,6 +7880,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBeginRendering && "Function <vkCmdBeginRendering> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdBeginRendering( m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) );
   }
@@ -7136,6 +7932,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetViewportWithCount &&
+                       "Function <vkCmdSetViewportWithCount> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdSetViewportWithCount( m_commandBuffer, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
   }
@@ -7155,6 +7955,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetScissorWithCount &&
+                       "Function <vkCmdSetScissorWithCount> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdSetScissorWithCount( m_commandBuffer, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
   }
@@ -7189,6 +7993,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers2 &&
+                       "Function <vkCmdBindVertexBuffers2> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
     VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
@@ -7310,6 +8118,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirements &&
+                       "Function <vkGetDeviceBufferMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
     d.vkGetDeviceBufferMemoryRequirements(
@@ -7323,6 +8135,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirements &&
+                       "Function <vkGetDeviceBufferMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 &      memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
@@ -7349,6 +8165,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirements &&
+                       "Function <vkGetDeviceImageMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
     d.vkGetDeviceImageMemoryRequirements(
@@ -7362,6 +8182,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirements &&
+                       "Function <vkGetDeviceImageMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 &      memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
@@ -7391,6 +8215,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirements &&
+                       "Function <vkGetDeviceImageSparseMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
     uint32_t                                                                                                   sparseMemoryRequirementCount;
@@ -7412,14 +8240,19 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename SparseImageMemoryRequirements2Allocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
                                          Device::getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
                                               SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,
                                               Dispatch const &                                            d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirements &&
+                       "Function <vkGetDeviceImageSparseMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
       sparseImageMemoryRequirements2Allocator );
@@ -7459,6 +8292,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroySurfaceKHR && "Function <vkDestroySurfaceKHR> requires <VK_KHR_surface>" );
+#  endif
 
     d.vkDestroySurfaceKHR( m_instance,
                            static_cast<VkSurfaceKHR>( surface ),
@@ -7482,6 +8318,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroySurfaceKHR && "Function <vkDestroySurfaceKHR> requires <VK_KHR_surface>" );
+#  endif
 
     d.vkDestroySurfaceKHR( m_instance,
                            static_cast<VkSurfaceKHR>( surface ),
@@ -7506,6 +8345,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceSupportKHR && "Function <vkGetPhysicalDeviceSurfaceSupportKHR> requires <VK_KHR_surface>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Bool32 supported;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR(
@@ -7532,6 +8374,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR && "Function <vkGetPhysicalDeviceSurfaceCapabilitiesKHR> requires <VK_KHR_surface>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities;
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
@@ -7559,6 +8404,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormatsKHR && "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> requires <VK_KHR_surface>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats;
     uint32_t                                                                       surfaceFormatCount;
@@ -7585,14 +8433,16 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename SurfaceFormatKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
                        PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                                           SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
                                           Dispatch const &                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormatsKHR && "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> requires <VK_KHR_surface>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats( surfaceFormatKHRAllocator );
     uint32_t                                                                       surfaceFormatCount;
@@ -7635,6 +8485,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModesKHR && "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> requires <VK_KHR_surface>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator> presentModes;
     uint32_t                                                                   presentModeCount;
@@ -7661,14 +8514,16 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PresentModeKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
                        PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                                                PresentModeKHRAllocator &        presentModeKHRAllocator,
                                                Dispatch const &                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModesKHR && "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> requires <VK_KHR_surface>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator> presentModes( presentModeKHRAllocator );
     uint32_t                                                                   presentModeCount;
@@ -7717,6 +8572,9 @@ namespace VULKAN_HPP_NAMESPACE
                                 Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSwapchainKHR && "Function <vkCreateSwapchainKHR> requires <VK_KHR_swapchain>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
     VULKAN_HPP_NAMESPACE::Result       result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -7737,6 +8595,9 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSwapchainKHR && "Function <vkCreateSwapchainKHR> requires <VK_KHR_swapchain>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
     VULKAN_HPP_NAMESPACE::Result       result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -7768,6 +8629,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroySwapchainKHR && "Function <vkDestroySwapchainKHR> requires <VK_KHR_swapchain>" );
+#  endif
 
     d.vkDestroySwapchainKHR( m_device,
                              static_cast<VkSwapchainKHR>( swapchain ),
@@ -7791,6 +8655,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroySwapchainKHR && "Function <vkDestroySwapchainKHR> requires <VK_KHR_swapchain>" );
+#  endif
 
     d.vkDestroySwapchainKHR( m_device,
                              static_cast<VkSwapchainKHR>( swapchain ),
@@ -7815,6 +8682,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetSwapchainImagesKHR && "Function <vkGetSwapchainImagesKHR> requires <VK_KHR_swapchain>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator> swapchainImages;
     uint32_t                                                 swapchainImageCount;
@@ -7841,12 +8711,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename ImageAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::Image>::value, int>::type>
+            typename std::enable_if<std::is_same<typename ImageAllocator::value_type, VULKAN_HPP_NAMESPACE::Image>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type
                        Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetSwapchainImagesKHR && "Function <vkGetSwapchainImagesKHR> requires <VK_KHR_swapchain>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator> swapchainImages( imageAllocator );
     uint32_t                                                 swapchainImageCount;
@@ -7894,6 +8766,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                             Dispatch const &                   d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAcquireNextImageKHR && "Function <vkAcquireNextImageKHR> requires <VK_KHR_swapchain>" );
+#  endif
 
     uint32_t                     imageIndex;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireNextImageKHR(
@@ -7923,6 +8798,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                          Dispatch const &                             d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkQueuePresentKHR && "Function <vkQueuePresentKHR> requires <VK_KHR_swapchain>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) ) );
@@ -7948,6 +8826,10 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getGroupPresentCapabilitiesKHR( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPresentCapabilitiesKHR &&
+                       "Function <vkGetDeviceGroupPresentCapabilitiesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
     VULKAN_HPP_NAMESPACE::Result                            result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -7974,6 +8856,10 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceGroupSurfacePresentModesKHR &&
+                       "Function <vkGetDeviceGroupSurfacePresentModesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes;
     VULKAN_HPP_NAMESPACE::Result                         result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDeviceGroupSurfacePresentModesKHR(
@@ -8001,6 +8887,10 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDevicePresentRectanglesKHR &&
+                       "Function <vkGetPhysicalDevicePresentRectanglesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator> rects;
     uint32_t                                                   rectCount;
@@ -8027,12 +8917,15 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Rect2DAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::Rect2D>::value, int>::type>
+            typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, VULKAN_HPP_NAMESPACE::Rect2D>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type
     PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDevicePresentRectanglesKHR &&
+                       "Function <vkGetPhysicalDevicePresentRectanglesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator> rects( rect2DAllocator );
     uint32_t                                                   rectCount;
@@ -8073,6 +8966,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                              Dispatch const &                                      d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAcquireNextImage2KHR && "Function <vkAcquireNextImage2KHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
+#  endif
 
     uint32_t                     imageIndex;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -8106,6 +9002,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getDisplayPropertiesKHR( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> requires <VK_KHR_display>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties;
     uint32_t                                                                               propertyCount;
@@ -8129,14 +9028,17 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, properties );
   }
 
-  template <typename DisplayPropertiesKHRAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value, int>::type>
+  template <
+    typename DisplayPropertiesKHRAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
                        PhysicalDevice::getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> requires <VK_KHR_display>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties( displayPropertiesKHRAllocator );
     uint32_t                                                                               propertyCount;
@@ -8178,6 +9080,9 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getDisplayPlanePropertiesKHR( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> requires <VK_KHR_display>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties;
     uint32_t                                                                                         propertyCount;
@@ -8201,15 +9106,19 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, properties );
   }
 
-  template <typename DisplayPlanePropertiesKHRAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value, int>::type>
+  template <
+    typename DisplayPlanePropertiesKHRAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
     PhysicalDevice::getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> requires <VK_KHR_display>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties( displayPlanePropertiesKHRAllocator );
     uint32_t                                                                                         propertyCount;
@@ -8251,6 +9160,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneSupportedDisplaysKHR && "Function <vkGetDisplayPlaneSupportedDisplaysKHR> requires <VK_KHR_display>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator> displays;
     uint32_t                                                           displayCount;
@@ -8276,12 +9188,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename DisplayKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type
     PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneSupportedDisplaysKHR && "Function <vkGetDisplayPlaneSupportedDisplaysKHR> requires <VK_KHR_display>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator> displays( displayKHRAllocator );
     uint32_t                                                           displayCount;
@@ -8324,6 +9238,9 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDisplayModePropertiesKHR && "Function <vkGetDisplayModePropertiesKHR> requires <VK_KHR_display>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties;
     uint32_t                                                                                       propertyCount;
@@ -8350,8 +9267,8 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename DisplayModePropertiesKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value,
+                                    int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
     PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
@@ -8359,6 +9276,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const &                    d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDisplayModePropertiesKHR && "Function <vkGetDisplayModePropertiesKHR> requires <VK_KHR_display>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties( displayModePropertiesKHRAllocator );
     uint32_t                                                                                       propertyCount;
@@ -8408,6 +9328,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDisplayModeKHR && "Function <vkCreateDisplayModeKHR> requires <VK_KHR_display>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DisplayModeKHR mode;
     VULKAN_HPP_NAMESPACE::Result         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -8430,6 +9353,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDisplayModeKHR && "Function <vkCreateDisplayModeKHR> requires <VK_KHR_display>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DisplayModeKHR mode;
     VULKAN_HPP_NAMESPACE::Result         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -8464,6 +9390,9 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneCapabilitiesKHR && "Function <vkGetDisplayPlaneCapabilitiesKHR> requires <VK_KHR_display>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities;
     VULKAN_HPP_NAMESPACE::Result                      result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDisplayPlaneCapabilitiesKHR(
@@ -8495,6 +9424,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDisplayPlaneSurfaceKHR && "Function <vkCreateDisplayPlaneSurfaceKHR> requires <VK_KHR_display>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDisplayPlaneSurfaceKHR(
@@ -8515,6 +9447,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDisplayPlaneSurfaceKHR && "Function <vkCreateDisplayPlaneSurfaceKHR> requires <VK_KHR_display>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDisplayPlaneSurfaceKHR(
@@ -8555,6 +9490,9 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                                                                             d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                                           result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR(
@@ -8570,8 +9508,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename SwapchainKHRAllocator,
             typename Dispatch,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
     Device::createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                    allocator,
@@ -8579,6 +9516,9 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                                                                             d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size(), swapchainKHRAllocator );
     VULKAN_HPP_NAMESPACE::Result                                           result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR(
@@ -8599,6 +9539,9 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
     VULKAN_HPP_NAMESPACE::Result       result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR(
@@ -8621,6 +9564,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                                                                             d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR> swapchains( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                    result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR(
@@ -8642,8 +9588,8 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Dispatch,
             typename SwapchainKHRAllocator,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::value, int>::type>
+            typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::value,
+                                    int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
     Device::createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
@@ -8652,6 +9598,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                                                                             d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR> swapchains( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                    result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR(
@@ -8678,6 +9627,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
     VULKAN_HPP_NAMESPACE::Result       result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR(
@@ -8718,6 +9670,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateXlibSurfaceKHR && "Function <vkCreateXlibSurfaceKHR> requires <VK_KHR_xlib_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -8738,6 +9693,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateXlibSurfaceKHR && "Function <vkCreateXlibSurfaceKHR> requires <VK_KHR_xlib_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -8767,6 +9725,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceXlibPresentationSupportKHR &&
+                       "Function <vkGetPhysicalDeviceXlibPresentationSupportKHR> requires <VK_KHR_xlib_surface>" );
+#    endif
 
     VkBool32 result = d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID );
 
@@ -8799,6 +9761,9 @@ namespace VULKAN_HPP_NAMESPACE
                                    Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateXcbSurfaceKHR && "Function <vkCreateXcbSurfaceKHR> requires <VK_KHR_xcb_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -8819,6 +9784,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateXcbSurfaceKHR && "Function <vkCreateXcbSurfaceKHR> requires <VK_KHR_xcb_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -8852,6 +9820,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                Dispatch const &   d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceXcbPresentationSupportKHR &&
+                       "Function <vkGetPhysicalDeviceXcbPresentationSupportKHR> requires <VK_KHR_xcb_surface>" );
+#    endif
 
     VkBool32 result = d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id );
 
@@ -8884,6 +9856,9 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateWaylandSurfaceKHR && "Function <vkCreateWaylandSurfaceKHR> requires <VK_KHR_wayland_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateWaylandSurfaceKHR(
@@ -8904,6 +9879,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateWaylandSurfaceKHR && "Function <vkCreateWaylandSurfaceKHR> requires <VK_KHR_wayland_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateWaylandSurfaceKHR(
@@ -8934,6 +9912,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceWaylandPresentationSupportKHR &&
+                       "Function <vkGetPhysicalDeviceWaylandPresentationSupportKHR> requires <VK_KHR_wayland_surface>" );
+#    endif
 
     VkBool32 result = d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display );
 
@@ -8966,6 +9948,9 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateAndroidSurfaceKHR && "Function <vkCreateAndroidSurfaceKHR> requires <VK_KHR_android_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAndroidSurfaceKHR(
@@ -8986,6 +9971,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateAndroidSurfaceKHR && "Function <vkCreateAndroidSurfaceKHR> requires <VK_KHR_android_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAndroidSurfaceKHR(
@@ -9026,6 +10014,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateWin32SurfaceKHR && "Function <vkCreateWin32SurfaceKHR> requires <VK_KHR_win32_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -9046,6 +10037,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateWin32SurfaceKHR && "Function <vkCreateWin32SurfaceKHR> requires <VK_KHR_win32_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -9093,6 +10087,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDebugReportCallbackEXT && "Function <vkCreateDebugReportCallbackEXT> requires <VK_EXT_debug_report>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback;
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDebugReportCallbackEXT(
@@ -9113,6 +10110,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDebugReportCallbackEXT && "Function <vkCreateDebugReportCallbackEXT> requires <VK_EXT_debug_report>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback;
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDebugReportCallbackEXT(
@@ -9145,6 +10145,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                   Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDebugReportCallbackEXT && "Function <vkDestroyDebugReportCallbackEXT> requires <VK_EXT_debug_report>" );
+#  endif
 
     d.vkDestroyDebugReportCallbackEXT(
       m_instance,
@@ -9170,6 +10173,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDebugReportCallbackEXT && "Function <vkDestroyDebugReportCallbackEXT> requires <VK_EXT_debug_report>" );
+#  endif
 
     d.vkDestroyDebugReportCallbackEXT(
       m_instance,
@@ -9211,6 +10217,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                           Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDebugReportMessageEXT && "Function <vkDebugReportMessageEXT> requires <VK_EXT_debug_report>" );
+#  endif
 
     d.vkDebugReportMessageEXT( m_instance,
                                static_cast<VkDebugReportFlagsEXT>( flags ),
@@ -9239,6 +10248,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDebugMarkerSetObjectTagEXT && "Function <vkDebugMarkerSetObjectTagEXT> requires <VK_EXT_debug_marker>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) ) );
@@ -9262,6 +10274,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDebugMarkerSetObjectNameEXT && "Function <vkDebugMarkerSetObjectNameEXT> requires <VK_EXT_debug_marker>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) ) );
@@ -9285,6 +10300,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                              Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdDebugMarkerBeginEXT && "Function <vkCmdDebugMarkerBeginEXT> requires <VK_EXT_debug_marker>" );
+#  endif
 
     d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
   }
@@ -9311,6 +10329,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                               Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdDebugMarkerInsertEXT && "Function <vkCmdDebugMarkerInsertEXT> requires <VK_EXT_debug_marker>" );
+#  endif
 
     d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
   }
@@ -9334,6 +10355,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoCapabilitiesKHR && "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities;
     VULKAN_HPP_NAMESPACE::Result               result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceVideoCapabilitiesKHR(
@@ -9348,6 +10372,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoCapabilitiesKHR && "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     StructureChain<X, Y, Z...>                   structureChain;
     VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR & capabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>();
@@ -9380,6 +10407,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR &&
+                       "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties;
     uint32_t                                                                                       videoFormatPropertyCount;
@@ -9409,8 +10440,8 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename VideoFormatPropertiesKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>::value,
+                                    int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
     PhysicalDevice::getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
@@ -9418,6 +10449,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const &                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR &&
+                       "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties( videoFormatPropertiesKHRAllocator );
     uint32_t                                                                                       videoFormatPropertyCount;
@@ -9467,6 +10502,9 @@ namespace VULKAN_HPP_NAMESPACE
                                    Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateVideoSessionKHR && "Function <vkCreateVideoSessionKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession;
     VULKAN_HPP_NAMESPACE::Result          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -9487,6 +10525,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateVideoSessionKHR && "Function <vkCreateVideoSessionKHR> requires <VK_KHR_video_queue>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession;
     VULKAN_HPP_NAMESPACE::Result          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -9518,6 +10559,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                          Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionKHR && "Function <vkDestroyVideoSessionKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     d.vkDestroyVideoSessionKHR(
       m_device,
@@ -9542,6 +10586,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionKHR && "Function <vkDestroyVideoSessionKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     d.vkDestroyVideoSessionKHR(
       m_device,
@@ -9571,6 +10618,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetVideoSessionMemoryRequirementsKHR && "Function <vkGetVideoSessionMemoryRequirementsKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator> memoryRequirements;
     uint32_t                                                                                                         memoryRequirementsCount;
@@ -9600,8 +10650,9 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename VideoSessionMemoryRequirementsKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
     Device::getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR        videoSession,
@@ -9609,6 +10660,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                             d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetVideoSessionMemoryRequirementsKHR && "Function <vkGetVideoSessionMemoryRequirementsKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator> memoryRequirements(
       videoSessionMemoryRequirementsKHRAllocator );
@@ -9660,6 +10714,9 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const &                                                                                    d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBindVideoSessionMemoryKHR && "Function <vkBindVideoSessionMemoryKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkBindVideoSessionMemoryKHR( m_device,
@@ -9694,6 +10751,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                                                  d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateVideoSessionParametersKHR && "Function <vkCreateVideoSessionParametersKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters;
     VULKAN_HPP_NAMESPACE::Result                    result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateVideoSessionParametersKHR(
@@ -9714,6 +10774,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                                  d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateVideoSessionParametersKHR && "Function <vkCreateVideoSessionParametersKHR> requires <VK_KHR_video_queue>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters;
     VULKAN_HPP_NAMESPACE::Result                    result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateVideoSessionParametersKHR(
@@ -9750,6 +10813,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                                                  d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkUpdateVideoSessionParametersKHR && "Function <vkUpdateVideoSessionParametersKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkUpdateVideoSessionParametersKHR( m_device,
@@ -9778,6 +10844,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                    Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionParametersKHR && "Function <vkDestroyVideoSessionParametersKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     d.vkDestroyVideoSessionParametersKHR(
       m_device,
@@ -9803,6 +10872,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionParametersKHR && "Function <vkDestroyVideoSessionParametersKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     d.vkDestroyVideoSessionParametersKHR(
       m_device,
@@ -9825,6 +10897,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                              Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBeginVideoCodingKHR && "Function <vkCmdBeginVideoCodingKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) );
   }
@@ -9844,6 +10919,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                            Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdEndVideoCodingKHR && "Function <vkCmdEndVideoCodingKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) );
   }
@@ -9863,6 +10941,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdControlVideoCodingKHR && "Function <vkCmdControlVideoCodingKHR> requires <VK_KHR_video_queue>" );
+#  endif
 
     d.vkCmdControlVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) );
   }
@@ -9884,6 +10965,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdDecodeVideoKHR && "Function <vkCmdDecodeVideoKHR> requires <VK_KHR_video_decode_queue>" );
+#  endif
 
     d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>( &decodeInfo ) );
   }
@@ -9918,6 +11002,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBindTransformFeedbackBuffersEXT && "Function <vkCmdBindTransformFeedbackBuffersEXT> requires <VK_EXT_transform_feedback>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
     VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
@@ -9965,6 +11052,9 @@ namespace VULKAN_HPP_NAMESPACE
                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBeginTransformFeedbackEXT && "Function <vkCmdBeginTransformFeedbackEXT> requires <VK_EXT_transform_feedback>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
 #  else
@@ -10006,6 +11096,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdEndTransformFeedbackEXT && "Function <vkCmdEndTransformFeedbackEXT> requires <VK_EXT_transform_feedback>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
 #  else
@@ -10084,6 +11177,9 @@ namespace VULKAN_HPP_NAMESPACE
                                Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateCuModuleNVX && "Function <vkCreateCuModuleNVX> requires <VK_NVX_binary_import>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::CuModuleNVX module;
     VULKAN_HPP_NAMESPACE::Result      result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -10104,6 +11200,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateCuModuleNVX && "Function <vkCreateCuModuleNVX> requires <VK_NVX_binary_import>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::CuModuleNVX module;
     VULKAN_HPP_NAMESPACE::Result      result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -10140,6 +11239,9 @@ namespace VULKAN_HPP_NAMESPACE
                                  Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateCuFunctionNVX && "Function <vkCreateCuFunctionNVX> requires <VK_NVX_binary_import>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::CuFunctionNVX function;
     VULKAN_HPP_NAMESPACE::Result        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -10160,6 +11262,9 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateCuFunctionNVX && "Function <vkCreateCuFunctionNVX> requires <VK_NVX_binary_import>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::CuFunctionNVX function;
     VULKAN_HPP_NAMESPACE::Result        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -10191,6 +11296,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyCuModuleNVX && "Function <vkDestroyCuModuleNVX> requires <VK_NVX_binary_import>" );
+#  endif
 
     d.vkDestroyCuModuleNVX( m_device,
                             static_cast<VkCuModuleNVX>( module ),
@@ -10214,6 +11322,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyCuModuleNVX && "Function <vkDestroyCuModuleNVX> requires <VK_NVX_binary_import>" );
+#  endif
 
     d.vkDestroyCuModuleNVX( m_device,
                             static_cast<VkCuModuleNVX>( module ),
@@ -10237,6 +11348,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                        Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyCuFunctionNVX && "Function <vkDestroyCuFunctionNVX> requires <VK_NVX_binary_import>" );
+#  endif
 
     d.vkDestroyCuFunctionNVX( m_device,
                               static_cast<VkCuFunctionNVX>( function ),
@@ -10260,6 +11374,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyCuFunctionNVX && "Function <vkDestroyCuFunctionNVX> requires <VK_NVX_binary_import>" );
+#  endif
 
     d.vkDestroyCuFunctionNVX( m_device,
                               static_cast<VkCuFunctionNVX>( function ),
@@ -10281,6 +11398,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                            Dispatch const &                              d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCuLaunchKernelNVX && "Function <vkCmdCuLaunchKernelNVX> requires <VK_NVX_binary_import>" );
+#  endif
 
     d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) );
   }
@@ -10302,6 +11422,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                             Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageViewHandleNVX && "Function <vkGetImageViewHandleNVX> requires <VK_NVX_image_view_handle>" );
+#  endif
 
     uint32_t result = d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) );
 
@@ -10325,6 +11448,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageViewAddressNVX && "Function <vkGetImageViewAddressNVX> requires <VK_NVX_image_view_handle>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties;
     VULKAN_HPP_NAMESPACE::Result                        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -10403,6 +11529,9 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const &                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetShaderInfoAMD && "Function <vkGetShaderInfoAMD> requires <VK_AMD_shader_info>" );
+#  endif
 
     std::vector<uint8_t, Uint8_tAllocator> info;
     size_t                                 infoSize;
@@ -10437,8 +11566,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Uint8_tAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type>
+            typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
                        Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
                               VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
@@ -10447,6 +11575,9 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const &                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetShaderInfoAMD && "Function <vkGetShaderInfoAMD> requires <VK_AMD_shader_info>" );
+#  endif
 
     std::vector<uint8_t, Uint8_tAllocator> info( uint8_tAllocator );
     size_t                                 infoSize;
@@ -10496,6 +11627,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                            Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBeginRenderingKHR && "Function <vkCmdBeginRenderingKHR> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdBeginRenderingKHR( m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) );
   }
@@ -10533,6 +11667,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                                                   d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateStreamDescriptorSurfaceGGP && "Function <vkCreateStreamDescriptorSurfaceGGP> requires <VK_GGP_stream_descriptor_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateStreamDescriptorSurfaceGGP(
@@ -10553,6 +11690,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                                                   d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateStreamDescriptorSurfaceGGP && "Function <vkCreateStreamDescriptorSurfaceGGP> requires <VK_GGP_stream_descriptor_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateStreamDescriptorSurfaceGGP(
@@ -10606,6 +11746,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                                      d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV &&
+                       "Function <vkGetPhysicalDeviceExternalImageFormatPropertiesNV> requires <VK_NV_external_memory_capabilities>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties;
     VULKAN_HPP_NAMESPACE::Result                          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -10643,6 +11787,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandleNV && "Function <vkGetMemoryWin32HandleNV> requires <VK_NV_external_memory_win32>" );
+#    endif
 
     HANDLE                       handle;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -10670,6 +11817,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2KHR &&
+                       "Function <vkGetPhysicalDeviceFeatures2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
     d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
@@ -10682,6 +11833,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2KHR &&
+                       "Function <vkGetPhysicalDeviceFeatures2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 &  features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
@@ -10705,6 +11860,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
     d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
@@ -10717,6 +11876,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>  structureChain;
     VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
@@ -10742,6 +11905,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
     d.vkGetPhysicalDeviceFormatProperties2KHR(
@@ -10755,6 +11922,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::FormatProperties2 &        formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
@@ -10783,6 +11954,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -10799,6 +11974,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     StructureChain<X, Y, Z...>                     structureChain;
     VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
@@ -10828,6 +12007,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties;
     uint32_t                                                                                   queueFamilyPropertyCount;
@@ -10844,14 +12027,18 @@ namespace VULKAN_HPP_NAMESPACE
     return queueFamilyProperties;
   }
 
-  template <typename QueueFamilyProperties2Allocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value, int>::type>
+  template <
+    typename QueueFamilyProperties2Allocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
     PhysicalDevice::getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties( queueFamilyProperties2Allocator );
     uint32_t                                                                                   queueFamilyPropertyCount;
@@ -10873,6 +12060,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<StructureChain, StructureChainAllocator>      structureChains;
     std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
@@ -10902,12 +12093,15 @@ namespace VULKAN_HPP_NAMESPACE
   template <typename StructureChain,
             typename StructureChainAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type>
+            typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
     PhysicalDevice::getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<StructureChain, StructureChainAllocator>      structureChains( structureChainAllocator );
     std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
@@ -10949,6 +12143,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceMemoryProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
     d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
@@ -10961,6 +12159,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceMemoryProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>        structureChain;
     VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
@@ -10991,6 +12193,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                                                   d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
     uint32_t                                                                                               propertyCount;
@@ -11010,16 +12216,21 @@ namespace VULKAN_HPP_NAMESPACE
     return properties;
   }
 
-  template <typename SparseImageFormatProperties2Allocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value, int>::type>
+  template <
+    typename SparseImageFormatProperties2Allocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
     PhysicalDevice::getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
                                                         SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
                                                         Dispatch const &                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties( sparseImageFormatProperties2Allocator );
     uint32_t                                                                                               propertyCount;
@@ -11060,6 +12271,10 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPeerMemoryFeaturesKHR &&
+                       "Function <vkGetDeviceGroupPeerMemoryFeaturesKHR> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
     d.vkGetDeviceGroupPeerMemoryFeaturesKHR(
@@ -11113,6 +12328,9 @@ namespace VULKAN_HPP_NAMESPACE
                                  Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateViSurfaceNN && "Function <vkCreateViSurfaceNN> requires <VK_NN_vi_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -11133,6 +12351,9 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateViSurfaceNN && "Function <vkCreateViSurfaceNN> requires <VK_NN_vi_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -11180,6 +12401,10 @@ namespace VULKAN_HPP_NAMESPACE
     Instance::enumeratePhysicalDeviceGroupsKHR( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroupsKHR &&
+                       "Function <vkEnumeratePhysicalDeviceGroupsKHR> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties;
     uint32_t                                                                                                 physicalDeviceGroupCount;
@@ -11205,13 +12430,18 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PhysicalDeviceGroupPropertiesAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
     Instance::enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroupsKHR &&
+                       "Function <vkEnumeratePhysicalDeviceGroupsKHR> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties(
       physicalDeviceGroupPropertiesAllocator );
@@ -11257,6 +12487,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalBufferPropertiesKHR &&
+                       "Function <vkGetPhysicalDeviceExternalBufferPropertiesKHR> requires <VK_KHR_external_memory_capabilities> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
     d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice,
@@ -11286,6 +12520,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandleKHR && "Function <vkGetMemoryWin32HandleKHR> requires <VK_KHR_external_memory_win32>" );
+#    endif
 
     HANDLE                       handle;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -11316,6 +12553,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandlePropertiesKHR && "Function <vkGetMemoryWin32HandlePropertiesKHR> requires <VK_KHR_external_memory_win32>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
     VULKAN_HPP_NAMESPACE::Result                         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -11347,6 +12587,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                      Dispatch const &                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetMemoryFdKHR && "Function <vkGetMemoryFdKHR> requires <VK_KHR_external_memory_fd>" );
+#  endif
 
     int                          fd;
     VULKAN_HPP_NAMESPACE::Result result =
@@ -11374,6 +12617,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetMemoryFdPropertiesKHR && "Function <vkGetMemoryFdPropertiesKHR> requires <VK_KHR_external_memory_fd>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties;
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetMemoryFdPropertiesKHR(
@@ -11405,6 +12651,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                        Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR &&
+                       "Function <vkGetPhysicalDeviceExternalSemaphorePropertiesKHR> requires <VK_KHR_external_semaphore_capabilities> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
     d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice,
@@ -11434,6 +12684,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkImportSemaphoreWin32HandleKHR && "Function <vkImportSemaphoreWin32HandleKHR> requires <VK_KHR_external_semaphore_win32>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) ) );
@@ -11458,6 +12711,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetSemaphoreWin32HandleKHR && "Function <vkGetSemaphoreWin32HandleKHR> requires <VK_KHR_external_semaphore_win32>" );
+#    endif
 
     HANDLE                       handle;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -11485,6 +12741,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkImportSemaphoreFdKHR && "Function <vkImportSemaphoreFdKHR> requires <VK_KHR_external_semaphore_fd>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) ) );
@@ -11509,6 +12768,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetSemaphoreFdKHR && "Function <vkGetSemaphoreFdKHR> requires <VK_KHR_external_semaphore_fd>" );
+#  endif
 
     int                          fd;
     VULKAN_HPP_NAMESPACE::Result result =
@@ -11548,6 +12810,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                                                         d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetKHR && "Function <vkCmdPushDescriptorSetKHR> requires <VK_KHR_push_descriptor>" );
+#  endif
 
     d.vkCmdPushDescriptorSetKHR( m_commandBuffer,
                                  static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
@@ -11579,6 +12844,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                           Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetWithTemplateKHR &&
+                       "Function <vkCmdPushDescriptorSetWithTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_KHR_push_descriptor>" );
+#  endif
 
     d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer,
                                              static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
@@ -11604,6 +12873,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBeginConditionalRenderingEXT && "Function <vkCmdBeginConditionalRenderingEXT> requires <VK_EXT_conditional_rendering>" );
+#  endif
 
     d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) );
   }
@@ -11640,6 +12912,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                Dispatch const &                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplateKHR &&
+                       "Function <vkCreateDescriptorUpdateTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate;
     VULKAN_HPP_NAMESPACE::Result                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorUpdateTemplateKHR(
@@ -11660,6 +12936,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const &                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplateKHR &&
+                       "Function <vkCreateDescriptorUpdateTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate;
     VULKAN_HPP_NAMESPACE::Result                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorUpdateTemplateKHR(
@@ -11693,6 +12973,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                      Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplateKHR &&
+                       "Function <vkDestroyDescriptorUpdateTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
+#  endif
 
     d.vkDestroyDescriptorUpdateTemplateKHR(
       m_device,
@@ -11720,6 +13004,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                      Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSetWithTemplateKHR &&
+                       "Function <vkUpdateDescriptorSetWithTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
+#  endif
 
     d.vkUpdateDescriptorSetWithTemplateKHR( m_device,
                                             static_cast<VkDescriptorSet>( descriptorSet ),
@@ -11748,6 +13036,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                                                         d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetViewportWScalingNV && "Function <vkCmdSetViewportWScalingNV> requires <VK_NV_clip_space_w_scaling>" );
+#  endif
 
     d.vkCmdSetViewportWScalingNV(
       m_commandBuffer, firstViewport, viewportWScalings.size(), reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) );
@@ -11768,6 +13059,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE void PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkReleaseDisplayEXT && "Function <vkReleaseDisplayEXT> requires <VK_EXT_direct_mode_display>" );
+#  endif
 
     d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) );
   }
@@ -11791,6 +13085,9 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAcquireXlibDisplayEXT && "Function <vkAcquireXlibDisplayEXT> requires <VK_EXT_acquire_xlib_display>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
@@ -11816,6 +13113,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetRandROutputDisplayEXT && "Function <vkGetRandROutputDisplayEXT> requires <VK_EXT_acquire_xlib_display>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DisplayKHR display;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -11831,6 +13131,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetRandROutputDisplayEXT && "Function <vkGetRandROutputDisplayEXT> requires <VK_EXT_acquire_xlib_display>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::DisplayKHR display;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -11863,6 +13166,10 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT &&
+                       "Function <vkGetPhysicalDeviceSurfaceCapabilities2EXT> requires <VK_EXT_display_surface_counter>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT surfaceCapabilities;
     VULKAN_HPP_NAMESPACE::Result                  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT(
@@ -11892,6 +13199,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                          Dispatch const &                                  d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDisplayPowerControlEXT && "Function <vkDisplayPowerControlEXT> requires <VK_EXT_display_control>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) ) );
@@ -11922,6 +13232,9 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkRegisterDeviceEventEXT && "Function <vkRegisterDeviceEventEXT> requires <VK_EXT_display_control>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Fence  fence;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkRegisterDeviceEventEXT(
@@ -11942,6 +13255,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkRegisterDeviceEventEXT && "Function <vkRegisterDeviceEventEXT> requires <VK_EXT_display_control>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Fence  fence;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkRegisterDeviceEventEXT(
@@ -11981,6 +13297,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkRegisterDisplayEventEXT && "Function <vkRegisterDisplayEventEXT> requires <VK_EXT_display_control>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Fence  fence;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkRegisterDisplayEventEXT(
@@ -12003,6 +13322,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkRegisterDisplayEventEXT && "Function <vkRegisterDisplayEventEXT> requires <VK_EXT_display_control>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Fence  fence;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkRegisterDisplayEventEXT(
@@ -12036,6 +13358,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetSwapchainCounterEXT && "Function <vkGetSwapchainCounterEXT> requires <VK_EXT_display_control>" );
+#  endif
 
     uint64_t                     counterValue;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -12065,6 +13390,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetRefreshCycleDurationGOOGLE && "Function <vkGetRefreshCycleDurationGOOGLE> requires <VK_GOOGLE_display_timing>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties;
     VULKAN_HPP_NAMESPACE::Result                     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetRefreshCycleDurationGOOGLE(
@@ -12096,6 +13424,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPastPresentationTimingGOOGLE && "Function <vkGetPastPresentationTimingGOOGLE> requires <VK_GOOGLE_display_timing>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings;
     uint32_t                                                                                               presentationTimingCount;
@@ -12123,10 +13454,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, presentationTimings );
   }
 
-  template <typename PastPresentationTimingGOOGLEAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value, int>::type>
+  template <
+    typename PastPresentationTimingGOOGLEAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
     Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
@@ -12134,6 +13466,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPastPresentationTimingGOOGLE && "Function <vkGetPastPresentationTimingGOOGLE> requires <VK_GOOGLE_display_timing>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings(
       pastPresentationTimingGOOGLEAllocator );
@@ -12182,6 +13517,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetDiscardRectangleEXT && "Function <vkCmdSetDiscardRectangleEXT> requires <VK_EXT_discard_rectangles>" );
+#  endif
 
     d.vkCmdSetDiscardRectangleEXT(
       m_commandBuffer, firstDiscardRectangle, discardRectangles.size(), reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) );
@@ -12224,6 +13562,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSetHdrMetadataEXT && "Function <vkSetHdrMetadataEXT> requires <VK_EXT_hdr_metadata>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
 #  else
@@ -12263,6 +13604,9 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRenderPass2KHR && "Function <vkCreateRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -12283,6 +13627,9 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRenderPass2KHR && "Function <vkCreateRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::RenderPass renderPass;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -12315,6 +13662,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                              Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass2KHR && "Function <vkCmdBeginRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
+#  endif
 
     d.vkCmdBeginRenderPass2KHR(
       m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
@@ -12338,6 +13688,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                          Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdNextSubpass2KHR && "Function <vkCmdNextSubpass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
+#  endif
 
     d.vkCmdNextSubpass2KHR(
       m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
@@ -12358,6 +13711,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                            Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdEndRenderPass2KHR && "Function <vkCmdEndRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
+#  endif
 
     d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
   }
@@ -12379,6 +13735,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                      Dispatch const &                   d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetSwapchainStatusKHR && "Function <vkGetSwapchainStatusKHR> requires <VK_KHR_shared_presentable_image>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
@@ -12410,6 +13769,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                              d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalFencePropertiesKHR &&
+                       "Function <vkGetPhysicalDeviceExternalFencePropertiesKHR> requires <VK_KHR_external_fence_capabilities> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
     d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice,
@@ -12438,6 +13801,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkImportFenceWin32HandleKHR && "Function <vkImportFenceWin32HandleKHR> requires <VK_KHR_external_fence_win32>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) ) );
@@ -12463,6 +13829,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetFenceWin32HandleKHR && "Function <vkGetFenceWin32HandleKHR> requires <VK_KHR_external_fence_win32>" );
+#    endif
 
     HANDLE                       handle;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -12490,6 +13859,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkImportFenceFdKHR && "Function <vkImportFenceFdKHR> requires <VK_KHR_external_fence_fd>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) ) );
@@ -12514,6 +13886,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                     Dispatch const &                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetFenceFdKHR && "Function <vkGetFenceFdKHR> requires <VK_KHR_external_fence_fd>" );
+#  endif
 
     int                          fd;
     VULKAN_HPP_NAMESPACE::Result result =
@@ -12551,6 +13926,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR &&
+                       "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" );
+#  endif
 
     std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
               std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
@@ -12588,11 +13967,10 @@ namespace VULKAN_HPP_NAMESPACE
   template <typename PerformanceCounterKHRAllocator,
             typename PerformanceCounterDescriptionKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename B2,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>::value &&
-                                      std::is_same<typename B2::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>::value,
-                                    int>::type>
+            typename std::enable_if<
+              std::is_same<typename PerformanceCounterKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>::value &&
+                std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
                                        std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
@@ -12602,6 +13980,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                      Dispatch const &                            d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR &&
+                       "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" );
+#  endif
 
     std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
               std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
@@ -12655,6 +14037,10 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR &&
+                       "Function <vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR> requires <VK_KHR_performance_query>" );
+#  endif
 
     uint32_t numPasses;
     d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
@@ -12678,6 +14064,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAcquireProfilingLockKHR && "Function <vkAcquireProfilingLockKHR> requires <VK_KHR_performance_query>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) ) );
@@ -12714,6 +14103,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR &&
+                       "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> requires <VK_KHR_get_surface_capabilities2>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR surfaceCapabilities;
     VULKAN_HPP_NAMESPACE::Result                  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -12730,6 +14123,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR &&
+                       "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> requires <VK_KHR_get_surface_capabilities2>" );
+#  endif
 
     StructureChain<X, Y, Z...>                      structureChain;
     VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR & surfaceCapabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>();
@@ -12762,6 +14159,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR &&
+                       "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats;
     uint32_t                                                                         surfaceFormatCount;
@@ -12791,14 +14192,17 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename SurfaceFormat2KHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
                        PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                                            SurfaceFormat2KHRAllocator &                                surfaceFormat2KHRAllocator,
                                            Dispatch const &                                            d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR &&
+                       "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats( surfaceFormat2KHRAllocator );
     uint32_t                                                                         surfaceFormatCount;
@@ -12831,6 +14235,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR &&
+                       "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" );
+#  endif
 
     std::vector<StructureChain, StructureChainAllocator> structureChains;
     std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats;
@@ -12871,14 +14279,17 @@ namespace VULKAN_HPP_NAMESPACE
   template <typename StructureChain,
             typename StructureChainAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type>
+            typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
                        PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                                            StructureChainAllocator &                                   structureChainAllocator,
                                            Dispatch const &                                            d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR &&
+                       "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" );
+#  endif
 
     std::vector<StructureChain, StructureChainAllocator> structureChains( structureChainAllocator );
     std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats;
@@ -12936,6 +14347,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getDisplayProperties2KHR( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceDisplayProperties2KHR> requires <VK_KHR_get_display_properties2>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties;
     uint32_t                                                                                 propertyCount;
@@ -12959,15 +14374,19 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, properties );
   }
 
-  template <typename DisplayProperties2KHRAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>::value, int>::type>
+  template <
+    typename DisplayProperties2KHRAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
     PhysicalDevice::getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceDisplayProperties2KHR> requires <VK_KHR_get_display_properties2>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties( displayProperties2KHRAllocator );
     uint32_t                                                                                 propertyCount;
@@ -13009,6 +14428,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getDisplayPlaneProperties2KHR( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> requires <VK_KHR_get_display_properties2>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties;
     uint32_t                                                                                           propertyCount;
@@ -13032,15 +14455,20 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, properties );
   }
 
-  template <typename DisplayPlaneProperties2KHRAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>::value, int>::type>
+  template <
+    typename DisplayPlaneProperties2KHRAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
     PhysicalDevice::getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR &&
+                       "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> requires <VK_KHR_get_display_properties2>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties( displayPlaneProperties2KHRAllocator );
     uint32_t                                                                                           propertyCount;
@@ -13083,6 +14511,9 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function <vkGetDisplayModeProperties2KHR> requires <VK_KHR_get_display_properties2>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties;
     uint32_t                                                                                         propertyCount;
@@ -13107,10 +14538,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, properties );
   }
 
-  template <typename DisplayModeProperties2KHRAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>::value, int>::type>
+  template <
+    typename DisplayModeProperties2KHRAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
     PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR     display,
@@ -13118,6 +14550,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function <vkGetDisplayModeProperties2KHR> requires <VK_KHR_get_display_properties2>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties( displayModeProperties2KHRAllocator );
     uint32_t                                                                                         propertyCount;
@@ -13161,6 +14596,9 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneCapabilities2KHR && "Function <vkGetDisplayPlaneCapabilities2KHR> requires <VK_KHR_get_display_properties2>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities;
     VULKAN_HPP_NAMESPACE::Result                       result =
@@ -13197,6 +14635,9 @@ namespace VULKAN_HPP_NAMESPACE
                                    Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateIOSSurfaceMVK && "Function <vkCreateIOSSurfaceMVK> requires <VK_MVK_ios_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -13217,6 +14658,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateIOSSurfaceMVK && "Function <vkCreateIOSSurfaceMVK> requires <VK_MVK_ios_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -13257,6 +14701,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateMacOSSurfaceMVK && "Function <vkCreateMacOSSurfaceMVK> requires <VK_MVK_macos_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -13277,6 +14724,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateMacOSSurfaceMVK && "Function <vkCreateMacOSSurfaceMVK> requires <VK_MVK_macos_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -13309,6 +14759,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSetDebugUtilsObjectNameEXT && "Function <vkSetDebugUtilsObjectNameEXT> requires <VK_EXT_debug_utils>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) ) );
@@ -13332,6 +14785,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSetDebugUtilsObjectTagEXT && "Function <vkSetDebugUtilsObjectTagEXT> requires <VK_EXT_debug_utils>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) ) );
@@ -13355,6 +14811,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                          Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkQueueBeginDebugUtilsLabelEXT && "Function <vkQueueBeginDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
+#  endif
 
     d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
   }
@@ -13381,6 +14840,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                           Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkQueueInsertDebugUtilsLabelEXT && "Function <vkQueueInsertDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
+#  endif
 
     d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
   }
@@ -13400,6 +14862,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                  Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBeginDebugUtilsLabelEXT && "Function <vkCmdBeginDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
+#  endif
 
     d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
   }
@@ -13426,6 +14891,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                   Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdInsertDebugUtilsLabelEXT && "Function <vkCmdInsertDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
+#  endif
 
     d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
   }
@@ -13453,6 +14921,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDebugUtilsMessengerEXT && "Function <vkCreateDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger;
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDebugUtilsMessengerEXT(
@@ -13473,6 +14944,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDebugUtilsMessengerEXT && "Function <vkCreateDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger;
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDebugUtilsMessengerEXT(
@@ -13505,6 +14979,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                   Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDebugUtilsMessengerEXT && "Function <vkDestroyDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" );
+#  endif
 
     d.vkDestroyDebugUtilsMessengerEXT(
       m_instance,
@@ -13530,6 +15007,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDebugUtilsMessengerEXT && "Function <vkDestroyDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" );
+#  endif
 
     d.vkDestroyDebugUtilsMessengerEXT(
       m_instance,
@@ -13559,6 +15039,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                Dispatch const &                                                 d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSubmitDebugUtilsMessageEXT && "Function <vkSubmitDebugUtilsMessageEXT> requires <VK_EXT_debug_utils>" );
+#  endif
 
     d.vkSubmitDebugUtilsMessageEXT( m_instance,
                                     static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
@@ -13587,6 +15070,10 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetAndroidHardwareBufferPropertiesANDROID &&
+                       "Function <vkGetAndroidHardwareBufferPropertiesANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties;
     VULKAN_HPP_NAMESPACE::Result                                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -13601,6 +15088,10 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetAndroidHardwareBufferPropertiesANDROID &&
+                       "Function <vkGetAndroidHardwareBufferPropertiesANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" );
+#    endif
 
     StructureChain<X, Y, Z...>                                     structureChain;
     VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID & properties =
@@ -13630,6 +15121,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetMemoryAndroidHardwareBufferANDROID &&
+                       "Function <vkGetMemoryAndroidHardwareBufferANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" );
+#    endif
 
     struct AHardwareBuffer *     buffer;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -13671,6 +15166,9 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const &                                                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX(
@@ -13689,8 +15187,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PipelineAllocator,
             typename Dispatch,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type>
+            typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> Device::createExecutionGraphPipelinesAMDX(
     VULKAN_HPP_NAMESPACE::PipelineCache                                                                        pipelineCache,
     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
@@ -13699,6 +15196,9 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const &                                                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
     VULKAN_HPP_NAMESPACE::Result                                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX(
@@ -13723,6 +15223,9 @@ namespace VULKAN_HPP_NAMESPACE
                                               Dispatch const &                                                   d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Pipeline pipeline;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX(
@@ -13749,6 +15252,9 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
+#      endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX(
@@ -13772,10 +15278,10 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
   }
 
-  template <typename Dispatch,
-            typename PipelineAllocator,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type>
+  template <
+    typename Dispatch,
+    typename PipelineAllocator,
+    typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
                                          Device::createExecutionGraphPipelinesAMDXUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache                                                                        pipelineCache,
@@ -13785,6 +15291,9 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
+#      endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX(
@@ -13816,6 +15325,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const &                                                   d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::Pipeline pipeline;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX(
@@ -13853,6 +15365,10 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetExecutionGraphPipelineScratchSizeAMDX &&
+                       "Function <vkGetExecutionGraphPipelineScratchSizeAMDX> requires <VK_AMDX_shader_enqueue>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX sizeInfo;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetExecutionGraphPipelineScratchSizeAMDX(
@@ -13881,6 +15397,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Pipeline executionGraph, const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetExecutionGraphPipelineNodeIndexAMDX && "Function <vkGetExecutionGraphPipelineNodeIndexAMDX> requires <VK_AMDX_shader_enqueue>" );
+#    endif
 
     uint32_t                     nodeIndex;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetExecutionGraphPipelineNodeIndexAMDX(
@@ -13915,6 +15434,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                            Dispatch const &                                         d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdDispatchGraphAMDX && "Function <vkCmdDispatchGraphAMDX> requires <VK_AMDX_shader_enqueue>" );
+#    endif
 
     d.vkCmdDispatchGraphAMDX( m_commandBuffer, static_cast<VkDeviceAddress>( scratch ), reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( &countInfo ) );
   }
@@ -13937,6 +15459,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                    Dispatch const &                                         d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdDispatchGraphIndirectAMDX && "Function <vkCmdDispatchGraphIndirectAMDX> requires <VK_AMDX_shader_enqueue>" );
+#    endif
 
     d.vkCmdDispatchGraphIndirectAMDX(
       m_commandBuffer, static_cast<VkDeviceAddress>( scratch ), reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( &countInfo ) );
@@ -13969,6 +15494,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetSampleLocationsEXT && "Function <vkCmdSetSampleLocationsEXT> requires <VK_EXT_sample_locations>" );
+#  endif
 
     d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) );
   }
@@ -13990,6 +15518,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMultisamplePropertiesEXT &&
+                       "Function <vkGetPhysicalDeviceMultisamplePropertiesEXT> requires <VK_EXT_sample_locations>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties;
     d.vkGetPhysicalDeviceMultisamplePropertiesEXT(
@@ -14017,6 +15549,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2KHR &&
+                       "Function <vkGetImageMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
     d.vkGetImageMemoryRequirements2KHR(
@@ -14030,6 +15566,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2KHR &&
+                       "Function <vkGetImageMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 &      memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
@@ -14056,6 +15596,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2KHR &&
+                       "Function <vkGetBufferMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
     d.vkGetBufferMemoryRequirements2KHR(
@@ -14069,6 +15613,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2KHR &&
+                       "Function <vkGetBufferMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 &      memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
@@ -14098,6 +15646,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2KHR &&
+                       "Function <vkGetImageSparseMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
     uint32_t                                                                                                   sparseMemoryRequirementCount;
@@ -14119,14 +15671,19 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename SparseImageMemoryRequirements2Allocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
                                          Device::getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
                                                   SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
                                                   Dispatch const &                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2KHR &&
+                       "Function <vkGetImageSparseMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
       sparseImageMemoryRequirements2Allocator );
@@ -14172,6 +15729,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureKHR && "Function <vkCreateAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure;
     VULKAN_HPP_NAMESPACE::Result                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAccelerationStructureKHR(
@@ -14192,6 +15752,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureKHR && "Function <vkCreateAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure;
     VULKAN_HPP_NAMESPACE::Result                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAccelerationStructureKHR(
@@ -14225,6 +15788,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                   Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureKHR && "Function <vkDestroyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     d.vkDestroyAccelerationStructureKHR(
       m_device,
@@ -14250,6 +15816,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureKHR && "Function <vkDestroyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     d.vkDestroyAccelerationStructureKHR(
       m_device,
@@ -14280,6 +15849,9 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructuresKHR && "Function <vkCmdBuildAccelerationStructuresKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
 #  else
@@ -14323,6 +15895,10 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructuresIndirectKHR &&
+                       "Function <vkCmdBuildAccelerationStructuresIndirectKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() );
     VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() );
@@ -14377,6 +15953,9 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const &                                                                                                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBuildAccelerationStructuresKHR && "Function <vkBuildAccelerationStructuresKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
 #  else
@@ -14419,6 +15998,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCopyAccelerationStructureKHR && "Function <vkCopyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCopyAccelerationStructureKHR(
       m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ) );
@@ -14450,6 +16032,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCopyAccelerationStructureToMemoryKHR &&
+                       "Function <vkCopyAccelerationStructureToMemoryKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCopyAccelerationStructureToMemoryKHR(
       m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ) );
@@ -14481,6 +16067,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCopyMemoryToAccelerationStructureKHR &&
+                       "Function <vkCopyMemoryToAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCopyMemoryToAccelerationStructureKHR(
       m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ) );
@@ -14524,6 +16114,10 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkWriteAccelerationStructuresPropertiesKHR &&
+                       "Function <vkWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
     std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
@@ -14548,6 +16142,10 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const &                                                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkWriteAccelerationStructuresPropertiesKHR &&
+                       "Function <vkWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -14578,6 +16176,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyAccelerationStructureKHR && "Function <vkCmdCopyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) );
   }
@@ -14597,6 +16198,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyAccelerationStructureToMemoryKHR &&
+                       "Function <vkCmdCopyAccelerationStructureToMemoryKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     d.vkCmdCopyAccelerationStructureToMemoryKHR( m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) );
   }
@@ -14616,6 +16221,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToAccelerationStructureKHR &&
+                       "Function <vkCmdCopyMemoryToAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     d.vkCmdCopyMemoryToAccelerationStructureKHR( m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) );
   }
@@ -14637,6 +16246,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureDeviceAddressKHR &&
+                       "Function <vkGetAccelerationStructureDeviceAddressKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     VkDeviceAddress result =
       d.vkGetAccelerationStructureDeviceAddressKHR( m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) );
@@ -14673,6 +16286,10 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const &                                                                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdWriteAccelerationStructuresPropertiesKHR &&
+                       "Function <vkCmdWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     d.vkCmdWriteAccelerationStructuresPropertiesKHR( m_commandBuffer,
                                                      accelerationStructures.size(),
@@ -14701,6 +16318,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceAccelerationStructureCompatibilityKHR &&
+                       "Function <vkGetDeviceAccelerationStructureCompatibilityKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility;
     d.vkGetDeviceAccelerationStructureCompatibilityKHR( m_device,
@@ -14735,6 +16356,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureBuildSizesKHR &&
+                       "Function <vkGetAccelerationStructureBuildSizesKHR> requires <VK_KHR_acceleration_structure>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( maxPrimitiveCounts.size() == buildInfo.geometryCount );
 #  else
@@ -14790,6 +16415,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdTraceRaysKHR && "Function <vkCmdTraceRaysKHR> requires <VK_KHR_ray_tracing_pipeline>" );
+#  endif
 
     d.vkCmdTraceRaysKHR( m_commandBuffer,
                          reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
@@ -14832,6 +16460,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                                                                      d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR(
@@ -14854,8 +16485,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PipelineAllocator,
             typename Dispatch,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type>
+            typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
                                           VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,
@@ -14865,6 +16495,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &    d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
     VULKAN_HPP_NAMESPACE::Result                                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR(
@@ -14894,6 +16527,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                              d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Pipeline pipeline;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR(
@@ -14925,6 +16561,9 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                                                      d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR(
@@ -14952,10 +16591,10 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
   }
 
-  template <typename Dispatch,
-            typename PipelineAllocator,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type>
+  template <
+    typename Dispatch,
+    typename PipelineAllocator,
+    typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
                                          Device::createRayTracingPipelinesKHRUnique(
       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,
@@ -14966,6 +16605,9 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                                                      d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR(
@@ -15002,6 +16644,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                Dispatch const &                                              d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Pipeline pipeline;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR(
@@ -15045,6 +16690,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesKHR &&
+                       "Function <vkGetRayTracingShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
+#  endif
 
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
     std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
@@ -15060,6 +16709,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesKHR &&
+                       "Function <vkGetRayTracingShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetRayTracingShaderGroupHandlesKHR(
@@ -15090,6 +16743,10 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR &&
+                       "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
+#  endif
 
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
     std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
@@ -15105,6 +16762,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR &&
+                       "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
@@ -15142,6 +16803,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                               Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdTraceRaysIndirectKHR && "Function <vkCmdTraceRaysIndirectKHR> requires <VK_KHR_ray_tracing_pipeline>" );
+#  endif
 
     d.vkCmdTraceRaysIndirectKHR( m_commandBuffer,
                                  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
@@ -15194,6 +16858,10 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversionKHR &&
+                       "Function <vkCreateSamplerYcbcrConversionKHR> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSamplerYcbcrConversionKHR(
@@ -15214,6 +16882,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversionKHR &&
+                       "Function <vkCreateSamplerYcbcrConversionKHR> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSamplerYcbcrConversionKHR(
@@ -15246,6 +16918,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                    Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversionKHR &&
+                       "Function <vkDestroySamplerYcbcrConversionKHR> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
+#  endif
 
     d.vkDestroySamplerYcbcrConversionKHR(
       m_device,
@@ -15272,6 +16948,9 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const &                                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBindBufferMemory2KHR && "Function <vkBindBufferMemory2KHR> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkBindBufferMemory2KHR( m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
@@ -15296,6 +16975,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBindImageMemory2KHR && "Function <vkBindImageMemory2KHR> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkBindImageMemory2KHR( m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
@@ -15322,6 +17004,10 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageDrmFormatModifierPropertiesEXT &&
+                       "Function <vkGetImageDrmFormatModifierPropertiesEXT> requires <VK_EXT_image_drm_format_modifier>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties;
     VULKAN_HPP_NAMESPACE::Result                              result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetImageDrmFormatModifierPropertiesEXT(
@@ -15355,6 +17041,9 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateValidationCacheEXT && "Function <vkCreateValidationCacheEXT> requires <VK_EXT_validation_cache>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache;
     VULKAN_HPP_NAMESPACE::Result             result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateValidationCacheEXT(
@@ -15375,6 +17064,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateValidationCacheEXT && "Function <vkCreateValidationCacheEXT> requires <VK_EXT_validation_cache>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache;
     VULKAN_HPP_NAMESPACE::Result             result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateValidationCacheEXT(
@@ -15407,6 +17099,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                             Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyValidationCacheEXT && "Function <vkDestroyValidationCacheEXT> requires <VK_EXT_validation_cache>" );
+#  endif
 
     d.vkDestroyValidationCacheEXT(
       m_device,
@@ -15432,6 +17127,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyValidationCacheEXT && "Function <vkDestroyValidationCacheEXT> requires <VK_EXT_validation_cache>" );
+#  endif
 
     d.vkDestroyValidationCacheEXT(
       m_device,
@@ -15459,6 +17157,9 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                                                                         d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkMergeValidationCachesEXT && "Function <vkMergeValidationCachesEXT> requires <VK_EXT_validation_cache>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkMergeValidationCachesEXT(
       m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCaches.size(), reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) );
@@ -15484,6 +17185,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetValidationCacheDataEXT && "Function <vkGetValidationCacheDataEXT> requires <VK_EXT_validation_cache>" );
+#  endif
 
     std::vector<uint8_t, Uint8_tAllocator> data;
     size_t                                 dataSize;
@@ -15510,12 +17214,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Uint8_tAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type>
+            typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
     Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetValidationCacheDataEXT && "Function <vkGetValidationCacheDataEXT> requires <VK_EXT_validation_cache>" );
+#  endif
 
     std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator );
     size_t                                 dataSize;
@@ -15571,6 +17277,9 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const &                                                                           d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetViewportShadingRatePaletteNV && "Function <vkCmdSetViewportShadingRatePaletteNV> requires <VK_NV_shading_rate_image>" );
+#  endif
 
     d.vkCmdSetViewportShadingRatePaletteNV(
       m_commandBuffer, firstViewport, shadingRatePalettes.size(), reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) );
@@ -15598,6 +17307,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetCoarseSampleOrderNV && "Function <vkCmdSetCoarseSampleOrderNV> requires <VK_NV_shading_rate_image>" );
+#  endif
 
     d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer,
                                    static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
@@ -15630,6 +17342,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureNV && "Function <vkCreateAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure;
     VULKAN_HPP_NAMESPACE::Result                  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAccelerationStructureNV(
@@ -15650,6 +17365,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const &                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureNV && "Function <vkCreateAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure;
     VULKAN_HPP_NAMESPACE::Result                  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAccelerationStructureNV(
@@ -15683,6 +17401,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                  Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureNV && "Function <vkDestroyAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     d.vkDestroyAccelerationStructureNV(
       m_device,
@@ -15708,6 +17429,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureNV && "Function <vkDestroyAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     d.vkDestroyAccelerationStructureNV(
       m_device,
@@ -15735,6 +17459,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureMemoryRequirementsNV &&
+                       "Function <vkGetAccelerationStructureMemoryRequirementsNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR memoryRequirements;
     d.vkGetAccelerationStructureMemoryRequirementsNV( m_device,
@@ -15750,6 +17478,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureMemoryRequirementsNV &&
+                       "Function <vkGetAccelerationStructureMemoryRequirementsNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR &   memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR>();
@@ -15776,6 +17508,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBindAccelerationStructureMemoryNV && "Function <vkBindAccelerationStructureMemoryNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkBindAccelerationStructureMemoryNV(
       m_device, bindInfos.size(), reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) ) );
@@ -15821,6 +17556,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                       Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructureNV && "Function <vkCmdBuildAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     d.vkCmdBuildAccelerationStructureNV( m_commandBuffer,
                                          reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ),
@@ -15908,6 +17646,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                                                                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV(
@@ -15926,8 +17667,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PipelineAllocator,
             typename Dispatch,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type>
+            typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
                                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
@@ -15936,6 +17676,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                                                                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
     VULKAN_HPP_NAMESPACE::Result                                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV(
@@ -15960,6 +17703,9 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                                             d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Pipeline pipeline;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV(
@@ -15985,6 +17731,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                Dispatch const &                                                                                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV(
@@ -16008,10 +17757,10 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
   }
 
-  template <typename Dispatch,
-            typename PipelineAllocator,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type>
+  template <
+    typename Dispatch,
+    typename PipelineAllocator,
+    typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
                                          Device::createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
                                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
@@ -16020,6 +17769,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                Dispatch const &    d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV(
@@ -16051,6 +17803,9 @@ namespace VULKAN_HPP_NAMESPACE
                                               Dispatch const &                                             d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Pipeline pipeline;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV(
@@ -16090,6 +17845,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesNV &&
+                       "Function <vkGetRayTracingShaderGroupHandlesNV> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
+#  endif
 
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
     std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
@@ -16105,6 +17864,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesNV &&
+                       "Function <vkGetRayTracingShaderGroupHandlesNV> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetRayTracingShaderGroupHandlesNV(
@@ -16132,6 +17895,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureHandleNV && "Function <vkGetAccelerationStructureHandleNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
     std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
@@ -16147,6 +17913,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureHandleNV && "Function <vkGetAccelerationStructureHandleNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetAccelerationStructureHandleNV(
@@ -16184,6 +17953,10 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const &                                                                              d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdWriteAccelerationStructuresPropertiesNV &&
+                       "Function <vkCmdWriteAccelerationStructuresPropertiesNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer,
                                                     accelerationStructures.size(),
@@ -16209,6 +17982,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Device::compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCompileDeferredNV && "Function <vkCompileDeferredNV> requires <VK_NV_ray_tracing>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
@@ -16237,6 +18013,10 @@ namespace VULKAN_HPP_NAMESPACE
                                               Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupportKHR &&
+                       "Function <vkGetDescriptorSetLayoutSupportKHR> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
     d.vkGetDescriptorSetLayoutSupportKHR(
@@ -16251,6 +18031,10 @@ namespace VULKAN_HPP_NAMESPACE
                                               Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupportKHR &&
+                       "Function <vkGetDescriptorSetLayoutSupportKHR> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>   structureChain;
     VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
@@ -16325,6 +18109,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                Dispatch const &                                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetMemoryHostPointerPropertiesEXT && "Function <vkGetMemoryHostPointerPropertiesEXT> requires <VK_EXT_external_memory_host>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
     VULKAN_HPP_NAMESPACE::Result                         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -16373,6 +18160,10 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT &&
+                       "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains;
     uint32_t                                                                 timeDomainCount;
@@ -16398,12 +18189,15 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename TimeDomainKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
                        PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT &&
+                       "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains( timeDomainKHRAllocator );
     uint32_t                                                                 timeDomainCount;
@@ -16447,6 +18241,10 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                                                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT &&
+                       "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
+#  endif
 
     std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
       std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
@@ -16461,14 +18259,17 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Uint64_tAllocator,
             typename Dispatch,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type>
+            typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
     Device::getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
                                         Uint64_tAllocator &                                                                              uint64_tAllocator,
                                         Dispatch const &                                                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT &&
+                       "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
+#  endif
 
     std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
       std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) );
@@ -16486,6 +18287,10 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT &&
+                       "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
+#  endif
 
     std::pair<uint64_t, uint64_t> data_;
     uint64_t &                    timestamp    = data_.first;
@@ -16558,6 +18363,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                                                             d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetExclusiveScissorEnableNV && "Function <vkCmdSetExclusiveScissorEnableNV> requires <VK_NV_scissor_exclusive>" );
+#  endif
 
     d.vkCmdSetExclusiveScissorEnableNV(
       m_commandBuffer, firstExclusiveScissor, exclusiveScissorEnables.size(), reinterpret_cast<const VkBool32 *>( exclusiveScissorEnables.data() ) );
@@ -16581,6 +18389,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetExclusiveScissorNV && "Function <vkCmdSetExclusiveScissorNV> requires <VK_NV_scissor_exclusive>" );
+#  endif
 
     d.vkCmdSetExclusiveScissorNV(
       m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size(), reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) );
@@ -16601,6 +18412,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetCheckpointNV && "Function <vkCmdSetCheckpointNV> requires <VK_NV_device_diagnostic_checkpoints>" );
+#  endif
 
     d.vkCmdSetCheckpointNV( m_commandBuffer, reinterpret_cast<const void *>( &checkpointMarker ) );
   }
@@ -16621,6 +18435,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Queue::getCheckpointDataNV( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointDataNV && "Function <vkGetQueueCheckpointDataNV> requires <VK_NV_device_diagnostic_checkpoints>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> checkpointData;
     uint32_t                                                                       checkpointDataCount;
@@ -16638,12 +18455,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename CheckpointDataNVAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV>::value, int>::type>
+            typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
                                          Queue::getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointDataNV && "Function <vkGetQueueCheckpointDataNV> requires <VK_NV_device_diagnostic_checkpoints>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> checkpointData( checkpointDataNVAllocator );
     uint32_t                                                                       checkpointDataCount;
@@ -16677,6 +18496,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetSemaphoreCounterValueKHR && "Function <vkGetSemaphoreCounterValueKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
+#  endif
 
     uint64_t                     value;
     VULKAN_HPP_NAMESPACE::Result result =
@@ -16702,6 +18524,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkWaitSemaphoresKHR && "Function <vkWaitSemaphoresKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
@@ -16726,6 +18551,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Device::signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSignalSemaphoreKHR && "Function <vkSignalSemaphoreKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
@@ -16752,6 +18580,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkInitializePerformanceApiINTEL && "Function <vkInitializePerformanceApiINTEL> requires <VK_INTEL_performance_query>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) ) );
@@ -16782,6 +18613,9 @@ namespace VULKAN_HPP_NAMESPACE
     CommandBuffer::setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceMarkerINTEL && "Function <vkCmdSetPerformanceMarkerINTEL> requires <VK_INTEL_performance_query>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) ) );
@@ -16806,6 +18640,9 @@ namespace VULKAN_HPP_NAMESPACE
     CommandBuffer::setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceStreamMarkerINTEL && "Function <vkCmdSetPerformanceStreamMarkerINTEL> requires <VK_INTEL_performance_query>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) ) );
@@ -16830,6 +18667,9 @@ namespace VULKAN_HPP_NAMESPACE
     CommandBuffer::setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceOverrideINTEL && "Function <vkCmdSetPerformanceOverrideINTEL> requires <VK_INTEL_performance_query>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) ) );
@@ -16857,6 +18697,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAcquirePerformanceConfigurationINTEL && "Function <vkAcquirePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration;
     VULKAN_HPP_NAMESPACE::Result                        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -16875,6 +18718,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                                                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAcquirePerformanceConfigurationINTEL && "Function <vkAcquirePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration;
     VULKAN_HPP_NAMESPACE::Result                        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -16903,6 +18749,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkReleasePerformanceConfigurationINTEL && "Function <vkReleasePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
@@ -16926,6 +18775,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Device::release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkReleasePerformanceConfigurationINTEL && "Function <vkReleasePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
@@ -16949,6 +18801,10 @@ namespace VULKAN_HPP_NAMESPACE
     Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkQueueSetPerformanceConfigurationINTEL &&
+                       "Function <vkQueueSetPerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
@@ -16974,6 +18830,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPerformanceParameterINTEL && "Function <vkGetPerformanceParameterINTEL> requires <VK_INTEL_performance_query>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PerformanceValueINTEL value;
     VULKAN_HPP_NAMESPACE::Result                result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPerformanceParameterINTEL(
@@ -17020,6 +18879,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const &                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateImagePipeSurfaceFUCHSIA && "Function <vkCreateImagePipeSurfaceFUCHSIA> requires <VK_FUCHSIA_imagepipe_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateImagePipeSurfaceFUCHSIA(
@@ -17040,6 +18902,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateImagePipeSurfaceFUCHSIA && "Function <vkCreateImagePipeSurfaceFUCHSIA> requires <VK_FUCHSIA_imagepipe_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateImagePipeSurfaceFUCHSIA(
@@ -17080,6 +18945,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateMetalSurfaceEXT && "Function <vkCreateMetalSurfaceEXT> requires <VK_EXT_metal_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -17100,6 +18968,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateMetalSurfaceEXT && "Function <vkCreateMetalSurfaceEXT> requires <VK_EXT_metal_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -17136,6 +19007,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getFragmentShadingRatesKHR( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFragmentShadingRatesKHR &&
+                       "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> requires <VK_KHR_fragment_shading_rate>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator> fragmentShadingRates;
     uint32_t                                                                                                               fragmentShadingRateCount;
@@ -17162,14 +19037,19 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PhysicalDeviceFragmentShadingRateKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type,
+                                                 VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>::value,
+                                    int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
     PhysicalDevice::getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
                                                 Dispatch const &                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFragmentShadingRatesKHR &&
+                       "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> requires <VK_KHR_fragment_shading_rate>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator> fragmentShadingRates(
       physicalDeviceFragmentShadingRateKHRAllocator );
@@ -17213,12 +19093,63 @@ namespace VULKAN_HPP_NAMESPACE
                                                                    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetFragmentShadingRateKHR && "Function <vkCmdSetFragmentShadingRateKHR> requires <VK_KHR_fragment_shading_rate>" );
+#  endif
 
     d.vkCmdSetFragmentShadingRateKHR(
       m_commandBuffer, reinterpret_cast<const VkExtent2D *>( &fragmentSize ), reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
   }
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 
+  //=== VK_KHR_dynamic_rendering_local_read ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR * pLocationInfo,
+                                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    d.vkCmdSetRenderingAttachmentLocationsKHR( m_commandBuffer, reinterpret_cast<const VkRenderingAttachmentLocationInfoKHR *>( pLocationInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR & locationInfo,
+                                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetRenderingAttachmentLocationsKHR &&
+                       "Function <vkCmdSetRenderingAttachmentLocationsKHR> requires <VK_KHR_dynamic_rendering_local_read>" );
+#  endif
+
+    d.vkCmdSetRenderingAttachmentLocationsKHR( m_commandBuffer, reinterpret_cast<const VkRenderingAttachmentLocationInfoKHR *>( &locationInfo ) );
+  }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR * pLocationInfo,
+                                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    d.vkCmdSetRenderingInputAttachmentIndicesKHR( m_commandBuffer, reinterpret_cast<const VkRenderingInputAttachmentIndexInfoKHR *>( pLocationInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR & locationInfo,
+                                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetRenderingInputAttachmentIndicesKHR &&
+                       "Function <vkCmdSetRenderingInputAttachmentIndicesKHR> requires <VK_KHR_dynamic_rendering_local_read>" );
+#  endif
+
+    d.vkCmdSetRenderingInputAttachmentIndicesKHR( m_commandBuffer, reinterpret_cast<const VkRenderingInputAttachmentIndexInfoKHR *>( &locationInfo ) );
+  }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
   //=== VK_EXT_buffer_device_address ===
 
   template <typename Dispatch>
@@ -17235,6 +19166,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddressEXT &&
+                       "Function <vkGetBufferDeviceAddressEXT> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
+#  endif
 
     VkDeviceAddress result = d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
 
@@ -17261,6 +19196,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getToolPropertiesEXT( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolPropertiesEXT &&
+                       "Function <vkGetPhysicalDeviceToolPropertiesEXT> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties;
     uint32_t                                                                                               toolCount;
@@ -17284,15 +19223,20 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, toolProperties );
   }
 
-  template <typename PhysicalDeviceToolPropertiesAllocator,
-            typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value, int>::type>
+  template <
+    typename PhysicalDeviceToolPropertiesAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
     PhysicalDevice::getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolPropertiesEXT &&
+                       "Function <vkGetPhysicalDeviceToolPropertiesEXT> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties(
       physicalDeviceToolPropertiesAllocator );
@@ -17336,6 +19280,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkWaitForPresentKHR && "Function <vkWaitForPresentKHR> requires <VK_KHR_present_wait>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkWaitForPresentKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), presentId, timeout ) );
@@ -17365,6 +19312,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getCooperativeMatrixPropertiesNV( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV &&
+                       "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> requires <VK_NV_cooperative_matrix>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties;
     uint32_t                                                                                                 propertyCount;
@@ -17390,14 +19341,19 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename CooperativeMatrixPropertiesNVAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
     PhysicalDevice::getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
                                                       Dispatch const &                         d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV &&
+                       "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> requires <VK_NV_cooperative_matrix>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties(
       cooperativeMatrixPropertiesNVAllocator );
@@ -17441,6 +19397,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV &&
+                       "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> requires <VK_NV_coverage_reduction_mode>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations;
     uint32_t                                                                                                               combinationCount;
@@ -17467,14 +19427,19 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename FramebufferMixedSamplesCombinationNVAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>::value, int>::type>
+            typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type,
+                                                 VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>::value,
+                                    int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
     PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV(
       FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV &&
+                       "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> requires <VK_NV_coverage_reduction_mode>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations(
       framebufferMixedSamplesCombinationNVAllocator );
@@ -17524,6 +19489,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModes2EXT &&
+                       "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator> presentModes;
     uint32_t                                                                   presentModeCount;
@@ -17553,14 +19522,17 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PresentModeKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
                        PhysicalDevice::getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                                                 PresentModeKHRAllocator &                                   presentModeKHRAllocator,
                                                 Dispatch const &                                            d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModes2EXT &&
+                       "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator> presentModes( presentModeKHRAllocator );
     uint32_t                                                                   presentModeCount;
@@ -17603,6 +19575,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAcquireFullScreenExclusiveModeEXT && "Function <vkAcquireFullScreenExclusiveModeEXT> requires <VK_EXT_full_screen_exclusive>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
@@ -17626,6 +19601,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkReleaseFullScreenExclusiveModeEXT && "Function <vkReleaseFullScreenExclusiveModeEXT> requires <VK_EXT_full_screen_exclusive>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
@@ -17652,6 +19630,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceGroupSurfacePresentModes2EXT &&
+                       "Function <vkGetDeviceGroupSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes;
     VULKAN_HPP_NAMESPACE::Result                         result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT(
@@ -17686,6 +19668,9 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateHeadlessSurfaceEXT && "Function <vkCreateHeadlessSurfaceEXT> requires <VK_EXT_headless_surface>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateHeadlessSurfaceEXT(
@@ -17706,6 +19691,9 @@ namespace VULKAN_HPP_NAMESPACE
                                               Dispatch const &                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateHeadlessSurfaceEXT && "Function <vkCreateHeadlessSurfaceEXT> requires <VK_EXT_headless_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateHeadlessSurfaceEXT(
@@ -17737,6 +19725,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddressKHR &&
+                       "Function <vkGetBufferDeviceAddressKHR> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
+#  endif
 
     VkDeviceAddress result = d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
 
@@ -17758,6 +19750,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                        Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureAddressKHR &&
+                       "Function <vkGetBufferOpaqueCaptureAddressKHR> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
+#  endif
 
     uint64_t result = d.vkGetBufferOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
 
@@ -17779,6 +19775,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryOpaqueCaptureAddressKHR &&
+                       "Function <vkGetDeviceMemoryOpaqueCaptureAddressKHR> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
+#  endif
 
     uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
 
@@ -17847,6 +19847,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetViewportWithCountEXT &&
+                       "Function <vkCmdSetViewportWithCountEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdSetViewportWithCountEXT( m_commandBuffer, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
   }
@@ -17866,6 +19870,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetScissorWithCountEXT &&
+                       "Function <vkCmdSetScissorWithCountEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
   }
@@ -17900,6 +19908,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers2EXT &&
+                       "Function <vkCmdBindVertexBuffers2EXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
     VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
@@ -18000,6 +20012,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDeferredOperationKHR && "Function <vkCreateDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation;
     VULKAN_HPP_NAMESPACE::Result               result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDeferredOperationKHR(
@@ -18017,6 +20032,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDeferredOperationKHR && "Function <vkCreateDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation;
     VULKAN_HPP_NAMESPACE::Result               result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDeferredOperationKHR(
@@ -18048,6 +20066,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                               Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDeferredOperationKHR && "Function <vkDestroyDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" );
+#  endif
 
     d.vkDestroyDeferredOperationKHR(
       m_device,
@@ -18073,6 +20094,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyDeferredOperationKHR && "Function <vkDestroyDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" );
+#  endif
 
     d.vkDestroyDeferredOperationKHR(
       m_device,
@@ -18103,6 +20127,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeferredOperationResultKHR && "Function <vkGetDeferredOperationResultKHR> requires <VK_KHR_deferred_host_operations>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
@@ -18125,6 +20152,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                         Dispatch const &                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDeferredOperationJoinKHR && "Function <vkDeferredOperationJoinKHR> requires <VK_KHR_deferred_host_operations>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkDeferredOperationJoinKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
@@ -18158,6 +20188,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelineExecutablePropertiesKHR &&
+                       "Function <vkGetPipelineExecutablePropertiesKHR> requires <VK_KHR_pipeline_executable_properties>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties;
     uint32_t                                                                                                     executableCount;
@@ -18187,8 +20221,9 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PipelineExecutablePropertiesKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
     Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
@@ -18196,6 +20231,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                              d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelineExecutablePropertiesKHR &&
+                       "Function <vkGetPipelineExecutablePropertiesKHR> requires <VK_KHR_pipeline_executable_properties>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties(
       pipelineExecutablePropertiesKHRAllocator );
@@ -18246,6 +20285,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableStatisticsKHR &&
+                       "Function <vkGetPipelineExecutableStatisticsKHR> requires <VK_KHR_pipeline_executable_properties>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics;
     uint32_t                                                                                                   statisticCount;
@@ -18275,8 +20318,9 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PipelineExecutableStatisticKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
     Device::getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
@@ -18284,6 +20328,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableStatisticsKHR &&
+                       "Function <vkGetPipelineExecutableStatisticsKHR> requires <VK_KHR_pipeline_executable_properties>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics(
       pipelineExecutableStatisticKHRAllocator );
@@ -18335,6 +20383,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableInternalRepresentationsKHR &&
+                       "Function <vkGetPipelineExecutableInternalRepresentationsKHR> requires <VK_KHR_pipeline_executable_properties>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>
                                  internalRepresentations;
@@ -18365,8 +20417,9 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename PipelineExecutableInternalRepresentationKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type,
+                                                 VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>::value,
+                                    int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
     std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
     Device::getPipelineExecutableInternalRepresentationsKHR(
@@ -18375,6 +20428,10 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableInternalRepresentationsKHR &&
+                       "Function <vkGetPipelineExecutableInternalRepresentationsKHR> requires <VK_KHR_pipeline_executable_properties>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>
                                  internalRepresentations( pipelineExecutableInternalRepresentationKHRAllocator );
@@ -18420,6 +20477,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT & copyMemoryToImageInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCopyMemoryToImageEXT && "Function <vkCopyMemoryToImageEXT> requires <VK_EXT_host_image_copy>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkCopyMemoryToImageEXT( m_device, reinterpret_cast<const VkCopyMemoryToImageInfoEXT *>( &copyMemoryToImageInfo ) ) );
@@ -18443,6 +20503,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT & copyImageToMemoryInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCopyImageToMemoryEXT && "Function <vkCopyImageToMemoryEXT> requires <VK_EXT_host_image_copy>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkCopyImageToMemoryEXT( m_device, reinterpret_cast<const VkCopyImageToMemoryInfoEXT *>( &copyImageToMemoryInfo ) ) );
@@ -18466,6 +20529,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT & copyImageToImageInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCopyImageToImageEXT && "Function <vkCopyImageToImageEXT> requires <VK_EXT_host_image_copy>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkCopyImageToImageEXT( m_device, reinterpret_cast<const VkCopyImageToImageInfoEXT *>( &copyImageToImageInfo ) ) );
@@ -18492,6 +20558,9 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                                                                                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkTransitionImageLayoutEXT && "Function <vkTransitionImageLayoutEXT> requires <VK_EXT_host_image_copy>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkTransitionImageLayoutEXT( m_device, transitions.size(), reinterpret_cast<const VkHostImageLayoutTransitionInfoEXT *>( transitions.data() ) ) );
@@ -18520,6 +20589,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT(
+      d.vkGetImageSubresourceLayout2EXT &&
+      "Function <vkGetImageSubresourceLayout2EXT> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR layout;
     d.vkGetImageSubresourceLayout2EXT( m_device,
@@ -18535,6 +20609,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT(
+      d.vkGetImageSubresourceLayout2EXT &&
+      "Function <vkGetImageSubresourceLayout2EXT> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR &    layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR>();
@@ -18564,6 +20643,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkMapMemory2KHR && "Function <vkMapMemory2KHR> requires <VK_KHR_map_memory2>" );
+#  endif
 
     void *                       pData;
     VULKAN_HPP_NAMESPACE::Result result =
@@ -18588,6 +20670,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkUnmapMemory2KHR && "Function <vkUnmapMemory2KHR> requires <VK_KHR_map_memory2>" );
+#  endif
 
     d.vkUnmapMemory2KHR( m_device, reinterpret_cast<const VkMemoryUnmapInfoKHR *>( &memoryUnmapInfo ) );
   }
@@ -18609,6 +20694,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkReleaseSwapchainImagesEXT && "Function <vkReleaseSwapchainImagesEXT> requires <VK_EXT_swapchain_maintenance1>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkReleaseSwapchainImagesEXT( m_device, reinterpret_cast<const VkReleaseSwapchainImagesInfoEXT *>( &releaseInfo ) ) );
@@ -18638,6 +20726,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsNV &&
+                       "Function <vkGetGeneratedCommandsMemoryRequirementsNV> requires <VK_NV_device_generated_commands>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
     d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device,
@@ -18653,6 +20745,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsNV &&
+                       "Function <vkGetGeneratedCommandsMemoryRequirementsNV> requires <VK_NV_device_generated_commands>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 &      memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
@@ -18678,6 +20774,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                        Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdPreprocessGeneratedCommandsNV && "Function <vkCmdPreprocessGeneratedCommandsNV> requires <VK_NV_device_generated_commands>" );
+#  endif
 
     d.vkCmdPreprocessGeneratedCommandsNV( m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
   }
@@ -18700,6 +20799,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                     Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdExecuteGeneratedCommandsNV && "Function <vkCmdExecuteGeneratedCommandsNV> requires <VK_NV_device_generated_commands>" );
+#  endif
 
     d.vkCmdExecuteGeneratedCommandsNV(
       m_commandBuffer, static_cast<VkBool32>( isPreprocessed ), reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
@@ -18738,6 +20840,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutNV && "Function <vkCreateIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout;
     VULKAN_HPP_NAMESPACE::Result                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateIndirectCommandsLayoutNV(
@@ -18758,6 +20863,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutNV && "Function <vkCreateIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout;
     VULKAN_HPP_NAMESPACE::Result                   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateIndirectCommandsLayoutNV(
@@ -18791,6 +20899,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                   Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutNV && "Function <vkDestroyIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" );
+#  endif
 
     d.vkDestroyIndirectCommandsLayoutNV(
       m_device,
@@ -18816,6 +20927,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutNV && "Function <vkDestroyIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" );
+#  endif
 
     d.vkDestroyIndirectCommandsLayoutNV(
       m_device,
@@ -18840,6 +20954,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                           Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetDepthBias2EXT && "Function <vkCmdSetDepthBias2EXT> requires <VK_EXT_depth_bias_control>" );
+#  endif
 
     d.vkCmdSetDepthBias2EXT( m_commandBuffer, reinterpret_cast<const VkDepthBiasInfoEXT *>( &depthBiasInfo ) );
   }
@@ -18862,6 +20979,9 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAcquireDrmDisplayEXT && "Function <vkAcquireDrmDisplayEXT> requires <VK_EXT_acquire_drm_display>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireDrmDisplayEXT( m_physicalDevice, drmFd, static_cast<VkDisplayKHR>( display ) ) );
@@ -18887,6 +21007,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDrmDisplayEXT && "Function <vkGetDrmDisplayEXT> requires <VK_EXT_acquire_drm_display>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DisplayKHR display;
     VULKAN_HPP_NAMESPACE::Result     result =
@@ -18902,6 +21025,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDrmDisplayEXT && "Function <vkGetDrmDisplayEXT> requires <VK_EXT_acquire_drm_display>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DisplayKHR display;
     VULKAN_HPP_NAMESPACE::Result     result =
@@ -18937,6 +21063,9 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlotEXT && "Function <vkCreatePrivateDataSlotEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot;
     VULKAN_HPP_NAMESPACE::Result          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePrivateDataSlotEXT(
@@ -18957,6 +21086,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlotEXT && "Function <vkCreatePrivateDataSlotEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot;
     VULKAN_HPP_NAMESPACE::Result          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePrivateDataSlotEXT(
@@ -18988,6 +21120,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                             Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlotEXT && "Function <vkDestroyPrivateDataSlotEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkDestroyPrivateDataSlotEXT(
       m_device,
@@ -19017,6 +21152,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                     Dispatch const &                      d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSetPrivateDataEXT && "Function <vkSetPrivateDataEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkSetPrivateDataEXT( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) );
@@ -19045,6 +21183,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                              Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPrivateDataEXT && "Function <vkGetPrivateDataEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
+#  endif
 
     uint64_t data;
     d.vkGetPrivateDataEXT( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data );
@@ -19075,6 +21216,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                              Dispatch const &                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR &&
+                       "Function <vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR> requires <VK_KHR_video_encode_queue>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR qualityLevelProperties;
     VULKAN_HPP_NAMESPACE::Result                               result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -19092,6 +21237,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                              Dispatch const &                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR &&
+                       "Function <vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR> requires <VK_KHR_video_encode_queue>" );
+#  endif
 
     StructureChain<X, Y, Z...>                                   structureChain;
     VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR & qualityLevelProperties =
@@ -19131,6 +21280,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const &                                                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" );
+#  endif
 
     std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>> data_;
     VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR &                                                  feedbackInfo = data_.first;
@@ -19163,8 +21315,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Uint8_tAllocator,
             typename Dispatch,
-            typename B2,
-            typename std::enable_if<std::is_same<typename B2::value_type, uint8_t>::value, int>::type>
+            typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
     Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
@@ -19172,6 +21323,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const &                                                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" );
+#  endif
 
     std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>> data_(
       std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) );
@@ -19210,6 +21364,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const &                                                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" );
+#  endif
 
     std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>> data_;
     VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR &                                 feedbackInfo =
@@ -19246,8 +21403,7 @@ namespace VULKAN_HPP_NAMESPACE
             typename... Z,
             typename Uint8_tAllocator,
             typename Dispatch,
-            typename B2,
-            typename std::enable_if<std::is_same<typename B2::value_type, uint8_t>::value, int>::type>
+            typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
     Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
@@ -19255,6 +21411,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const &                                                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" );
+#  endif
 
     std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>> data_(
       std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) );
@@ -19302,6 +21461,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdEncodeVideoKHR && "Function <vkCmdEncodeVideoKHR> requires <VK_KHR_video_encode_queue>" );
+#  endif
 
     d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoEncodeInfoKHR *>( &encodeInfo ) );
   }
@@ -19331,6 +21493,9 @@ namespace VULKAN_HPP_NAMESPACE
                                 Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateCudaModuleNV && "Function <vkCreateCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::CudaModuleNV module;
     VULKAN_HPP_NAMESPACE::Result       result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -19351,6 +21516,9 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateCudaModuleNV && "Function <vkCreateCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::CudaModuleNV module;
     VULKAN_HPP_NAMESPACE::Result       result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -19382,6 +21550,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetCudaModuleCacheNV && "Function <vkGetCudaModuleCacheNV> requires <VK_NV_cuda_kernel_launch>" );
+#    endif
 
     std::vector<uint8_t, Uint8_tAllocator> cacheData;
     size_t                                 cacheSize;
@@ -19407,12 +21578,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Uint8_tAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type>
+            typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
                        Device::getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetCudaModuleCacheNV && "Function <vkGetCudaModuleCacheNV> requires <VK_NV_cuda_kernel_launch>" );
+#    endif
 
     std::vector<uint8_t, Uint8_tAllocator> cacheData( uint8_tAllocator );
     size_t                                 cacheSize;
@@ -19458,6 +21631,9 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateCudaFunctionNV && "Function <vkCreateCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::CudaFunctionNV function;
     VULKAN_HPP_NAMESPACE::Result         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -19478,6 +21654,9 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateCudaFunctionNV && "Function <vkCreateCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::CudaFunctionNV function;
     VULKAN_HPP_NAMESPACE::Result         result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -19509,6 +21688,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyCudaModuleNV && "Function <vkDestroyCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" );
+#    endif
 
     d.vkDestroyCudaModuleNV( m_device,
                              static_cast<VkCudaModuleNV>( module ),
@@ -19532,6 +21714,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyCudaModuleNV && "Function <vkDestroyCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" );
+#    endif
 
     d.vkDestroyCudaModuleNV( m_device,
                              static_cast<VkCudaModuleNV>( module ),
@@ -19555,6 +21740,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyCudaFunctionNV && "Function <vkDestroyCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" );
+#    endif
 
     d.vkDestroyCudaFunctionNV( m_device,
                                static_cast<VkCudaFunctionNV>( function ),
@@ -19578,6 +21766,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyCudaFunctionNV && "Function <vkDestroyCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" );
+#    endif
 
     d.vkDestroyCudaFunctionNV( m_device,
                                static_cast<VkCudaFunctionNV>( function ),
@@ -19599,6 +21790,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                             Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCudaLaunchKernelNV && "Function <vkCmdCudaLaunchKernelNV> requires <VK_NV_cuda_kernel_launch>" );
+#    endif
 
     d.vkCmdCudaLaunchKernelNV( m_commandBuffer, reinterpret_cast<const VkCudaLaunchInfoNV *>( &launchInfo ) );
   }
@@ -19622,6 +21816,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Device::exportMetalObjectsEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT metalObjectsInfo;
     d.vkExportMetalObjectsEXT( m_device, reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) );
@@ -19634,6 +21831,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Device::exportMetalObjectsEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>  structureChain;
     VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo = structureChain.template get<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT>();
@@ -19662,6 +21862,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetEvent2KHR && "Function <vkCmdSetEvent2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdSetEvent2KHR( m_commandBuffer, static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
   }
@@ -19694,6 +21897,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdWaitEvents2KHR && "Function <vkCmdWaitEvents2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() );
 #  else
@@ -19724,6 +21930,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                              Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier2KHR && "Function <vkCmdPipelineBarrier2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
   }
@@ -19756,6 +21965,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkQueueSubmit2KHR && "Function <vkQueueSubmit2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkQueueSubmit2KHR( m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) ) );
@@ -19792,6 +22004,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Queue::getCheckpointData2NV( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointData2NV && "Function <vkGetQueueCheckpointData2NV> requires <VK_KHR_synchronization2>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> checkpointData;
     uint32_t                                                                         checkpointDataCount;
@@ -19809,12 +22024,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename CheckpointData2NVAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV>::value, int>::type>
+            typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
                                          Queue::getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointData2NV && "Function <vkGetQueueCheckpointData2NV> requires <VK_KHR_synchronization2>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> checkpointData( checkpointData2NVAllocator );
     uint32_t                                                                         checkpointDataCount;
@@ -19848,6 +22065,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSizeEXT && "Function <vkGetDescriptorSetLayoutSizeEXT> requires <VK_EXT_descriptor_buffer>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DeviceSize layoutSizeInBytes;
     d.vkGetDescriptorSetLayoutSizeEXT( m_device, static_cast<VkDescriptorSetLayout>( layout ), reinterpret_cast<VkDeviceSize *>( &layoutSizeInBytes ) );
@@ -19872,6 +22092,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, uint32_t binding, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutBindingOffsetEXT &&
+                       "Function <vkGetDescriptorSetLayoutBindingOffsetEXT> requires <VK_EXT_descriptor_buffer>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DeviceSize offset;
     d.vkGetDescriptorSetLayoutBindingOffsetEXT( m_device, static_cast<VkDescriptorSetLayout>( layout ), binding, reinterpret_cast<VkDeviceSize *>( &offset ) );
@@ -19898,6 +22122,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> requires <VK_EXT_descriptor_buffer>" );
+#  endif
 
     d.vkGetDescriptorEXT( m_device, reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ), dataSize, pDescriptor );
   }
@@ -19907,6 +22134,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> requires <VK_EXT_descriptor_buffer>" );
+#  endif
 
     DescriptorType descriptor;
     d.vkGetDescriptorEXT(
@@ -19932,6 +22162,9 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorBuffersEXT && "Function <vkCmdBindDescriptorBuffersEXT> requires <VK_EXT_descriptor_buffer>" );
+#  endif
 
     d.vkCmdBindDescriptorBuffersEXT( m_commandBuffer, bindingInfos.size(), reinterpret_cast<const VkDescriptorBufferBindingInfoEXT *>( bindingInfos.data() ) );
   }
@@ -19966,6 +22199,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetDescriptorBufferOffsetsEXT && "Function <vkCmdSetDescriptorBufferOffsetsEXT> requires <VK_EXT_descriptor_buffer>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( bufferIndices.size() == offsets.size() );
 #  else
@@ -20011,6 +22247,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureDescriptorDataEXT &&
+                       "Function <vkGetBufferOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -20036,6 +22276,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDescriptorDataEXT &&
+                       "Function <vkGetImageOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -20061,6 +22305,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetImageViewOpaqueCaptureDescriptorDataEXT &&
+                       "Function <vkGetImageViewOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -20086,6 +22334,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetSamplerOpaqueCaptureDescriptorDataEXT &&
+                       "Function <vkGetSamplerOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -20112,6 +22364,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                     Dispatch const &                                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT &&
+                       "Function <vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
@@ -20190,6 +22446,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                              d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer2KHR && "Function <vkCmdCopyBuffer2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>( &copyBufferInfo ) );
   }
@@ -20209,6 +22468,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                        Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyImage2KHR && "Function <vkCmdCopyImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>( &copyImageInfo ) );
   }
@@ -20228,6 +22490,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage2KHR && "Function <vkCmdCopyBufferToImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdCopyBufferToImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>( &copyBufferToImageInfo ) );
   }
@@ -20247,6 +22512,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer2KHR && "Function <vkCmdCopyImageToBuffer2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>( &copyImageToBufferInfo ) );
   }
@@ -20266,6 +22534,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                        Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBlitImage2KHR && "Function <vkCmdBlitImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) );
   }
@@ -20285,6 +22556,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                           Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdResolveImage2KHR && "Function <vkCmdResolveImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
+#  endif
 
     d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) );
   }
@@ -20308,6 +22582,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Device::getFaultInfoEXT( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceFaultInfoEXT && "Function <vkGetDeviceFaultInfoEXT> requires <VK_EXT_device_fault>" );
+#  endif
 
     std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> data_;
     VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT &                                                    faultCounts = data_.first;
@@ -20339,6 +22616,9 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkAcquireWinrtDisplayNV && "Function <vkAcquireWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
@@ -20363,6 +22643,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function <vkGetWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::DisplayKHR display;
     VULKAN_HPP_NAMESPACE::Result     result =
@@ -20378,6 +22661,9 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function <vkGetWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::DisplayKHR display;
     VULKAN_HPP_NAMESPACE::Result     result =
@@ -20415,6 +22701,9 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDirectFBSurfaceEXT && "Function <vkCreateDirectFBSurfaceEXT> requires <VK_EXT_directfb_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDirectFBSurfaceEXT(
@@ -20435,6 +22724,9 @@ namespace VULKAN_HPP_NAMESPACE
                                               Dispatch const &                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateDirectFBSurfaceEXT && "Function <vkCreateDirectFBSurfaceEXT> requires <VK_EXT_directfb_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDirectFBSurfaceEXT(
@@ -20465,6 +22757,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT &&
+                       "Function <vkGetPhysicalDeviceDirectFBPresentationSupportEXT> requires <VK_EXT_directfb_surface>" );
+#    endif
 
     VkBool32 result = d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, &dfb );
 
@@ -20498,6 +22794,9 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const &                                                                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetVertexInputEXT && "Function <vkCmdSetVertexInputEXT> requires <VK_EXT_shader_object> or <VK_EXT_vertex_input_dynamic_state>" );
+#  endif
 
     d.vkCmdSetVertexInputEXT( m_commandBuffer,
                               vertexBindingDescriptions.size(),
@@ -20527,6 +22826,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetMemoryZirconHandleFUCHSIA && "Function <vkGetMemoryZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_memory>" );
+#    endif
 
     zx_handle_t                  zirconHandle;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -20560,6 +22862,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const &                                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetMemoryZirconHandlePropertiesFUCHSIA &&
+                       "Function <vkGetMemoryZirconHandlePropertiesFUCHSIA> requires <VK_FUCHSIA_external_memory>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties;
     VULKAN_HPP_NAMESPACE::Result                              result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -20593,6 +22899,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                                                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkImportSemaphoreZirconHandleFUCHSIA && "Function <vkImportSemaphoreZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_semaphore>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkImportSemaphoreZirconHandleFUCHSIA(
       m_device, reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) ) );
@@ -20619,6 +22928,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetSemaphoreZirconHandleFUCHSIA && "Function <vkGetSemaphoreZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_semaphore>" );
+#    endif
 
     zx_handle_t                  zirconHandle;
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -20655,6 +22967,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateBufferCollectionFUCHSIA && "Function <vkCreateBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection;
     VULKAN_HPP_NAMESPACE::Result                  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateBufferCollectionFUCHSIA(
@@ -20675,6 +22990,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const &                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateBufferCollectionFUCHSIA && "Function <vkCreateBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection;
     VULKAN_HPP_NAMESPACE::Result                  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateBufferCollectionFUCHSIA(
@@ -20709,6 +23027,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSetBufferCollectionImageConstraintsFUCHSIA &&
+                       "Function <vkSetBufferCollectionImageConstraintsFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkSetBufferCollectionImageConstraintsFUCHSIA(
       m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( &imageConstraintsInfo ) ) );
@@ -20737,6 +23059,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                          Dispatch const &                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSetBufferCollectionBufferConstraintsFUCHSIA &&
+                       "Function <vkSetBufferCollectionBufferConstraintsFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkSetBufferCollectionBufferConstraintsFUCHSIA(
       m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( &bufferConstraintsInfo ) ) );
@@ -20763,6 +23089,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                  Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyBufferCollectionFUCHSIA && "Function <vkDestroyBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
+#    endif
 
     d.vkDestroyBufferCollectionFUCHSIA(
       m_device,
@@ -20788,6 +23117,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyBufferCollectionFUCHSIA && "Function <vkDestroyBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
+#    endif
 
     d.vkDestroyBufferCollectionFUCHSIA(
       m_device,
@@ -20813,6 +23145,10 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetBufferCollectionPropertiesFUCHSIA &&
+                       "Function <vkGetBufferCollectionPropertiesFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties;
     VULKAN_HPP_NAMESPACE::Result                            result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetBufferCollectionPropertiesFUCHSIA(
@@ -20842,6 +23178,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI &&
+                       "Function <vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> requires <VK_HUAWEI_subpass_shading>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize;
     VULKAN_HPP_NAMESPACE::Result   result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
@@ -20891,6 +23231,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetMemoryRemoteAddressNV && "Function <vkGetMemoryRemoteAddressNV> requires <VK_NV_external_memory_rdma>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::RemoteAddressNV address;
     VULKAN_HPP_NAMESPACE::Result          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetMemoryRemoteAddressNV(
@@ -20919,6 +23262,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelinePropertiesEXT && "Function <vkGetPipelinePropertiesEXT> requires <VK_EXT_pipeline_properties>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::BaseOutStructure pipelineProperties;
     VULKAN_HPP_NAMESPACE::Result           result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelinePropertiesEXT(
@@ -20992,6 +23338,9 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateScreenSurfaceQNX && "Function <vkCreateScreenSurfaceQNX> requires <VK_QNX_screen_surface>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateScreenSurfaceQNX(
@@ -21012,6 +23361,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#      if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateScreenSurfaceQNX && "Function <vkCreateScreenSurfaceQNX> requires <VK_QNX_screen_surface>" );
+#      endif
 
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
     VULKAN_HPP_NAMESPACE::Result     result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateScreenSurfaceQNX(
@@ -21042,6 +23394,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceScreenPresentationSupportQNX &&
+                       "Function <vkGetPhysicalDeviceScreenPresentationSupportQNX> requires <VK_QNX_screen_surface>" );
+#    endif
 
     VkBool32 result = d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, &window );
 
@@ -21067,6 +23423,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetColorWriteEnableEXT && "Function <vkCmdSetColorWriteEnableEXT> requires <VK_EXT_color_write_enable>" );
+#  endif
 
     d.vkCmdSetColorWriteEnableEXT( m_commandBuffer, colorWriteEnables.size(), reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) );
   }
@@ -21104,6 +23463,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdDrawMultiEXT && "Function <vkCmdDrawMultiEXT> requires <VK_EXT_multi_draw>" );
+#  endif
 
     d.vkCmdDrawMultiEXT( m_commandBuffer,
                          vertexInfo.size(),
@@ -21138,6 +23500,9 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdDrawMultiIndexedEXT && "Function <vkCmdDrawMultiIndexedEXT> requires <VK_EXT_multi_draw>" );
+#  endif
 
     d.vkCmdDrawMultiIndexedEXT( m_commandBuffer,
                                 indexInfo.size(),
@@ -21172,6 +23537,9 @@ namespace VULKAN_HPP_NAMESPACE
                                Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateMicromapEXT && "Function <vkCreateMicromapEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MicromapEXT micromap;
     VULKAN_HPP_NAMESPACE::Result      result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -21192,6 +23560,9 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateMicromapEXT && "Function <vkCreateMicromapEXT> requires <VK_EXT_opacity_micromap>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::MicromapEXT micromap;
     VULKAN_HPP_NAMESPACE::Result      result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -21223,6 +23594,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyMicromapEXT && "Function <vkDestroyMicromapEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     d.vkDestroyMicromapEXT( m_device,
                             static_cast<VkMicromapEXT>( micromap ),
@@ -21246,6 +23620,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyMicromapEXT && "Function <vkDestroyMicromapEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     d.vkDestroyMicromapEXT( m_device,
                             static_cast<VkMicromapEXT>( micromap ),
@@ -21268,6 +23645,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBuildMicromapsEXT && "Function <vkCmdBuildMicromapsEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     d.vkCmdBuildMicromapsEXT( m_commandBuffer, infos.size(), reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) );
   }
@@ -21292,6 +23672,9 @@ namespace VULKAN_HPP_NAMESPACE
                                Dispatch const &                                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBuildMicromapsEXT && "Function <vkBuildMicromapsEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkBuildMicromapsEXT(
       m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), infos.size(), reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) ) );
@@ -21321,6 +23704,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                Dispatch const &                                  d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCopyMicromapEXT && "Function <vkCopyMicromapEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkCopyMicromapEXT( m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) ) );
@@ -21349,6 +23735,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCopyMicromapToMemoryEXT && "Function <vkCopyMicromapToMemoryEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCopyMicromapToMemoryEXT(
       m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) ) );
@@ -21377,6 +23766,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCopyMemoryToMicromapEXT && "Function <vkCopyMemoryToMicromapEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCopyMemoryToMicromapEXT(
       m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) ) );
@@ -21413,6 +23805,9 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                                                  d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkWriteMicromapsPropertiesEXT && "Function <vkWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
     std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
@@ -21437,6 +23832,9 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                                                                  d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkWriteMicromapsPropertiesEXT && "Function <vkWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     DataType                     data;
     VULKAN_HPP_NAMESPACE::Result result =
@@ -21465,6 +23863,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyMicromapEXT && "Function <vkCmdCopyMicromapEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     d.vkCmdCopyMicromapEXT( m_commandBuffer, reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) );
   }
@@ -21484,6 +23885,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                  Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyMicromapToMemoryEXT && "Function <vkCmdCopyMicromapToMemoryEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     d.vkCmdCopyMicromapToMemoryEXT( m_commandBuffer, reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) );
   }
@@ -21503,6 +23907,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                  Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToMicromapEXT && "Function <vkCmdCopyMemoryToMicromapEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     d.vkCmdCopyMemoryToMicromapEXT( m_commandBuffer, reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) );
   }
@@ -21535,6 +23942,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const &                                                                  d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdWriteMicromapsPropertiesEXT && "Function <vkCmdWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     d.vkCmdWriteMicromapsPropertiesEXT( m_commandBuffer,
                                         micromaps.size(),
@@ -21562,6 +23972,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceMicromapCompatibilityEXT && "Function <vkGetDeviceMicromapCompatibilityEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility;
     d.vkGetDeviceMicromapCompatibilityEXT( m_device,
@@ -21593,6 +24006,9 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetMicromapBuildSizesEXT && "Function <vkGetMicromapBuildSizesEXT> requires <VK_EXT_opacity_micromap>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT sizeInfo;
     d.vkGetMicromapBuildSizesEXT( m_device,
@@ -21650,6 +24066,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirementsKHR &&
+                       "Function <vkGetDeviceBufferMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
     d.vkGetDeviceBufferMemoryRequirementsKHR(
@@ -21663,6 +24083,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirementsKHR &&
+                       "Function <vkGetDeviceBufferMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 &      memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
@@ -21689,6 +24113,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirementsKHR &&
+                       "Function <vkGetDeviceImageMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
     d.vkGetDeviceImageMemoryRequirementsKHR(
@@ -21702,6 +24130,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirementsKHR &&
+                       "Function <vkGetDeviceImageMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 &      memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
@@ -21731,6 +24163,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirementsKHR &&
+                       "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
     uint32_t                                                                                                   sparseMemoryRequirementCount;
@@ -21752,14 +24188,19 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename SparseImageMemoryRequirements2Allocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
                                          Device::getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
                                                  SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,
                                                  Dispatch const &                                            d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirementsKHR &&
+                       "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
       sparseImageMemoryRequirements2Allocator );
@@ -21801,6 +24242,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const &                                                 d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutHostMappingInfoVALVE &&
+                       "Function <vkGetDescriptorSetLayoutHostMappingInfoVALVE> requires <VK_VALVE_descriptor_set_host_mapping>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE hostMapping;
     d.vkGetDescriptorSetLayoutHostMappingInfoVALVE( m_device,
@@ -21825,6 +24270,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                           Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDescriptorSetHostMappingVALVE &&
+                       "Function <vkGetDescriptorSetHostMappingVALVE> requires <VK_VALVE_descriptor_set_host_mapping>" );
+#  endif
 
     void * pData;
     d.vkGetDescriptorSetHostMappingVALVE( m_device, static_cast<VkDescriptorSet>( descriptorSet ), &pData );
@@ -21875,6 +24324,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToImageIndirectNV && "Function <vkCmdCopyMemoryToImageIndirectNV> requires <VK_NV_copy_memory_indirect>" );
+#  endif
 
     d.vkCmdCopyMemoryToImageIndirectNV( m_commandBuffer,
                                         static_cast<VkDeviceAddress>( copyBufferAddress ),
@@ -21904,6 +24356,9 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdDecompressMemoryNV && "Function <vkCmdDecompressMemoryNV> requires <VK_NV_memory_decompression>" );
+#  endif
 
     d.vkCmdDecompressMemoryNV(
       m_commandBuffer, decompressMemoryRegions.size(), reinterpret_cast<const VkDecompressMemoryRegionNV *>( decompressMemoryRegions.data() ) );
@@ -21940,6 +24395,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectMemoryRequirementsNV &&
+                       "Function <vkGetPipelineIndirectMemoryRequirementsNV> requires <VK_NV_device_generated_commands_compute>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
     d.vkGetPipelineIndirectMemoryRequirementsNV(
@@ -21954,6 +24413,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectMemoryRequirementsNV &&
+                       "Function <vkGetPipelineIndirectMemoryRequirementsNV> requires <VK_NV_device_generated_commands_compute>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::MemoryRequirements2 &      memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
@@ -21988,6 +24451,10 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectDeviceAddressNV &&
+                       "Function <vkGetPipelineIndirectDeviceAddressNV> requires <VK_NV_device_generated_commands_compute>" );
+#  endif
 
     VkDeviceAddress result = d.vkGetPipelineIndirectDeviceAddressNV( m_device, reinterpret_cast<const VkPipelineIndirectDeviceAddressInfoNV *>( &info ) );
 
@@ -21998,14 +24465,6 @@ namespace VULKAN_HPP_NAMESPACE
   //=== VK_EXT_extended_dynamic_state3 ===
 
   template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin,
-                                                                        Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    d.vkCmdSetTessellationDomainOriginEXT( m_commandBuffer, static_cast<VkTessellationDomainOrigin>( domainOrigin ) );
-  }
-
-  template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@@ -22043,6 +24502,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetSampleMaskEXT && "Function <vkCmdSetSampleMaskEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( sampleMask.size() == ( static_cast<uint32_t>( samples ) + 31 ) / 32 );
 #  else
@@ -22095,6 +24557,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendEnableEXT &&
+                       "Function <vkCmdSetColorBlendEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
+#  endif
 
     d.vkCmdSetColorBlendEnableEXT( m_commandBuffer, firstAttachment, colorBlendEnables.size(), reinterpret_cast<const VkBool32 *>( colorBlendEnables.data() ) );
   }
@@ -22119,6 +24585,10 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendEquationEXT &&
+                       "Function <vkCmdSetColorBlendEquationEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
+#  endif
 
     d.vkCmdSetColorBlendEquationEXT(
       m_commandBuffer, firstAttachment, colorBlendEquations.size(), reinterpret_cast<const VkColorBlendEquationEXT *>( colorBlendEquations.data() ) );
@@ -22143,6 +24613,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetColorWriteMaskEXT &&
+                       "Function <vkCmdSetColorWriteMaskEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
+#  endif
 
     d.vkCmdSetColorWriteMaskEXT(
       m_commandBuffer, firstAttachment, colorWriteMasks.size(), reinterpret_cast<const VkColorComponentFlags *>( colorWriteMasks.data() ) );
@@ -22150,6 +24624,14 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 
   template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin,
+                                                                        Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    d.vkCmdSetTessellationDomainOriginEXT( m_commandBuffer, static_cast<VkTessellationDomainOrigin>( domainOrigin ) );
+  }
+
+  template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@@ -22207,6 +24689,10 @@ namespace VULKAN_HPP_NAMESPACE
                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendAdvancedEXT &&
+                       "Function <vkCmdSetColorBlendAdvancedEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
+#  endif
 
     d.vkCmdSetColorBlendAdvancedEXT(
       m_commandBuffer, firstAttachment, colorBlendAdvanced.size(), reinterpret_cast<const VkColorBlendAdvancedEXT *>( colorBlendAdvanced.data() ) );
@@ -22270,6 +24756,10 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                                                        d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetViewportSwizzleNV &&
+                       "Function <vkCmdSetViewportSwizzleNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
+#  endif
 
     d.vkCmdSetViewportSwizzleNV(
       m_commandBuffer, firstViewport, viewportSwizzles.size(), reinterpret_cast<const VkViewportSwizzleNV *>( viewportSwizzles.data() ) );
@@ -22322,6 +24812,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                                       Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetCoverageModulationTableNV &&
+                       "Function <vkCmdSetCoverageModulationTableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
+#  endif
 
     d.vkCmdSetCoverageModulationTableNV( m_commandBuffer, coverageModulationTable.size(), coverageModulationTable.data() );
   }
@@ -22368,6 +24862,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetShaderModuleIdentifierEXT && "Function <vkGetShaderModuleIdentifierEXT> requires <VK_EXT_shader_module_identifier>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT identifier;
     d.vkGetShaderModuleIdentifierEXT( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) );
@@ -22393,6 +24890,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                     Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetShaderModuleCreateInfoIdentifierEXT &&
+                       "Function <vkGetShaderModuleCreateInfoIdentifierEXT> requires <VK_EXT_shader_module_identifier>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT identifier;
     d.vkGetShaderModuleCreateInfoIdentifierEXT(
@@ -22427,6 +24928,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV &&
+                       "Function <vkGetPhysicalDeviceOpticalFlowImageFormatsNV> requires <VK_NV_optical_flow>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator> imageFormatProperties;
     uint32_t                                                                                                           formatCount;
@@ -22456,8 +24961,9 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename OpticalFlowImageFormatPropertiesNVAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
     PhysicalDevice::getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
@@ -22465,6 +24971,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const &                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV &&
+                       "Function <vkGetPhysicalDeviceOpticalFlowImageFormatsNV> requires <VK_NV_optical_flow>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator> imageFormatProperties(
       opticalFlowImageFormatPropertiesNVAllocator );
@@ -22515,6 +25025,9 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                                             d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateOpticalFlowSessionNV && "Function <vkCreateOpticalFlowSessionNV> requires <VK_NV_optical_flow>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session;
     VULKAN_HPP_NAMESPACE::Result               result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateOpticalFlowSessionNV(
@@ -22535,6 +25048,9 @@ namespace VULKAN_HPP_NAMESPACE
                                               Dispatch const &                                             d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateOpticalFlowSessionNV && "Function <vkCreateOpticalFlowSessionNV> requires <VK_NV_optical_flow>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session;
     VULKAN_HPP_NAMESPACE::Result               result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateOpticalFlowSessionNV(
@@ -22566,6 +25082,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                               Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyOpticalFlowSessionNV && "Function <vkDestroyOpticalFlowSessionNV> requires <VK_NV_optical_flow>" );
+#  endif
 
     d.vkDestroyOpticalFlowSessionNV(
       m_device,
@@ -22590,6 +25109,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyOpticalFlowSessionNV && "Function <vkDestroyOpticalFlowSessionNV> requires <VK_NV_optical_flow>" );
+#  endif
 
     d.vkDestroyOpticalFlowSessionNV(
       m_device,
@@ -22623,6 +25145,9 @@ namespace VULKAN_HPP_NAMESPACE
                                            Dispatch const &                                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkBindOpticalFlowSessionImageNV && "Function <vkBindOpticalFlowSessionImageNV> requires <VK_NV_optical_flow>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result =
       static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkBindOpticalFlowSessionImageNV( m_device,
@@ -22653,6 +25178,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                               Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdOpticalFlowExecuteNV && "Function <vkCmdOpticalFlowExecuteNV> requires <VK_NV_optical_flow>" );
+#  endif
 
     d.vkCmdOpticalFlowExecuteNV(
       m_commandBuffer, static_cast<VkOpticalFlowSessionNV>( session ), reinterpret_cast<const VkOpticalFlowExecuteInfoNV *>( &executeInfo ) );
@@ -22692,6 +25220,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR & renderingAreaInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetRenderingAreaGranularityKHR && "Function <vkGetRenderingAreaGranularityKHR> requires <VK_KHR_maintenance5>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Extent2D granularity;
     d.vkGetRenderingAreaGranularityKHR(
@@ -22717,6 +25248,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayoutKHR && "Function <vkGetDeviceImageSubresourceLayoutKHR> requires <VK_KHR_maintenance5>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR layout;
     d.vkGetDeviceImageSubresourceLayoutKHR(
@@ -22730,6 +25264,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayoutKHR && "Function <vkGetDeviceImageSubresourceLayoutKHR> requires <VK_KHR_maintenance5>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR &    layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR>();
@@ -22759,6 +25296,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT(
+      d.vkGetImageSubresourceLayout2KHR &&
+      "Function <vkGetImageSubresourceLayout2KHR> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR layout;
     d.vkGetImageSubresourceLayout2KHR( m_device,
@@ -22774,6 +25316,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT(
+      d.vkGetImageSubresourceLayout2KHR &&
+      "Function <vkGetImageSubresourceLayout2KHR> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
     VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR &    layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR>();
@@ -22811,6 +25358,9 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const &                                                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator> shaders( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                                     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -22826,8 +25376,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename ShaderEXTAllocator,
             typename Dispatch,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT>::value, int>::type>
+            typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>::type
                        Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                 allocator,
@@ -22835,6 +25384,9 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const &                                                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator> shaders( createInfos.size(), shaderEXTAllocator );
     VULKAN_HPP_NAMESPACE::Result                                     result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -22855,6 +25407,9 @@ namespace VULKAN_HPP_NAMESPACE
                              Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::ShaderEXT shader;
     VULKAN_HPP_NAMESPACE::Result    result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -22877,6 +25432,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT> shaders( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -22896,10 +25454,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValueType( result, std::move( uniqueShaders ) );
   }
 
-  template <typename Dispatch,
-            typename ShaderEXTAllocator,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::value, int>::type>
+  template <
+    typename Dispatch,
+    typename ShaderEXTAllocator,
+    typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>::type
     Device::createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
@@ -22908,6 +25466,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
+#    endif
 
     std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT> shaders( createInfos.size() );
     VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -22934,6 +25495,9 @@ namespace VULKAN_HPP_NAMESPACE
                                    Dispatch const &                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::ShaderEXT shader;
     VULKAN_HPP_NAMESPACE::Result    result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -22966,6 +25530,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyShaderEXT && "Function <vkDestroyShaderEXT> requires <VK_EXT_shader_object>" );
+#  endif
 
     d.vkDestroyShaderEXT( m_device,
                           static_cast<VkShaderEXT>( shader ),
@@ -22989,6 +25556,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyShaderEXT && "Function <vkDestroyShaderEXT> requires <VK_EXT_shader_object>" );
+#  endif
 
     d.vkDestroyShaderEXT( m_device,
                           static_cast<VkShaderEXT>( shader ),
@@ -23010,6 +25580,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetShaderBinaryDataEXT && "Function <vkGetShaderBinaryDataEXT> requires <VK_EXT_shader_object>" );
+#  endif
 
     std::vector<uint8_t, Uint8_tAllocator> data;
     size_t                                 dataSize;
@@ -23035,12 +25608,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Uint8_tAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type>
+            typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
                        Device::getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetShaderBinaryDataEXT && "Function <vkGetShaderBinaryDataEXT> requires <VK_EXT_shader_object>" );
+#  endif
 
     std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator );
     size_t                                 dataSize;
@@ -23083,6 +25658,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBindShadersEXT && "Function <vkCmdBindShadersEXT> requires <VK_EXT_shader_object>" );
+#  endif
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( stages.size() == shaders.size() );
 #  else
@@ -23118,6 +25696,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetFramebufferTilePropertiesQCOM && "Function <vkGetFramebufferTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator> properties;
     uint32_t                                                                           propertiesCount;
@@ -23144,14 +25725,16 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename TilePropertiesQCOMAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>::value, int>::type>
+            typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
                        Device::getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
                                               TilePropertiesQCOMAllocator &     tilePropertiesQCOMAllocator,
                                               Dispatch const &                  d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetFramebufferTilePropertiesQCOM && "Function <vkGetFramebufferTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator> properties( tilePropertiesQCOMAllocator );
     uint32_t                                                                           propertiesCount;
@@ -23193,6 +25776,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetDynamicRenderingTilePropertiesQCOM && "Function <vkGetDynamicRenderingTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::TilePropertiesQCOM properties;
     d.vkGetDynamicRenderingTilePropertiesQCOM(
@@ -23221,6 +25807,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                         Dispatch const &                                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSetLatencySleepModeNV && "Function <vkSetLatencySleepModeNV> requires <VK_NV_low_latency2>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkSetLatencySleepModeNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepModeInfoNV *>( &sleepModeInfo ) ) );
@@ -23246,6 +25835,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkLatencySleepNV && "Function <vkLatencySleepNV> requires <VK_NV_low_latency2>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
       d.vkLatencySleepNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( &sleepInfo ) ) );
@@ -23271,6 +25863,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkSetLatencyMarkerNV && "Function <vkSetLatencyMarkerNV> requires <VK_NV_low_latency2>" );
+#  endif
 
     d.vkSetLatencyMarkerNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkSetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
   }
@@ -23291,6 +25886,9 @@ namespace VULKAN_HPP_NAMESPACE
     Device::getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetLatencyTimingsNV && "Function <vkGetLatencyTimingsNV> requires <VK_NV_low_latency2>" );
+#  endif
 
     VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV latencyMarkerInfo;
     d.vkGetLatencyTimingsNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
@@ -23313,6 +25911,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkQueueNotifyOutOfBandNV && "Function <vkQueueNotifyOutOfBandNV> requires <VK_NV_low_latency2>" );
+#  endif
 
     d.vkQueueNotifyOutOfBandNV( m_queue, reinterpret_cast<const VkOutOfBandQueueTypeInfoNV *>( &queueTypeInfo ) );
   }
@@ -23336,6 +25937,10 @@ namespace VULKAN_HPP_NAMESPACE
     PhysicalDevice::getCooperativeMatrixPropertiesKHR( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR &&
+                       "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR> requires <VK_KHR_cooperative_matrix>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator> properties;
     uint32_t                                                                                                   propertyCount;
@@ -23361,14 +25966,19 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename CooperativeMatrixPropertiesKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>::value, int>::type>
+            typename std::enable_if<
+              std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>::value,
+              int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
     PhysicalDevice::getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator,
                                                        Dispatch const &                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR &&
+                       "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR> requires <VK_KHR_cooperative_matrix>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator> properties(
       cooperativeMatrixPropertiesKHRAllocator );
@@ -23422,6 +26032,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetScreenBufferPropertiesQNX && "Function <vkGetScreenBufferPropertiesQNX> requires <VK_QNX_external_memory_screen_buffer>" );
+#    endif
 
     VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX properties;
     VULKAN_HPP_NAMESPACE::Result                    result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
@@ -23436,6 +26049,9 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetScreenBufferPropertiesQNX && "Function <vkGetScreenBufferPropertiesQNX> requires <VK_QNX_external_memory_screen_buffer>" );
+#    endif
 
     StructureChain<X, Y, Z...>                        structureChain;
     VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>();
@@ -23448,6 +26064,16 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
 
+  //=== VK_KHR_line_rasterization ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    d.vkCmdSetLineStippleKHR( m_commandBuffer, lineStippleFactor, lineStipplePattern );
+  }
+
   //=== VK_KHR_calibrated_timestamps ===
 
   template <typename Dispatch>
@@ -23466,6 +26092,10 @@ namespace VULKAN_HPP_NAMESPACE
                        PhysicalDevice::getCalibrateableTimeDomainsKHR( Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR &&
+                       "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains;
     uint32_t                                                                 timeDomainCount;
@@ -23491,12 +26121,15 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename TimeDomainKHRAllocator,
             typename Dispatch,
-            typename B1,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type>
+            typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
                        PhysicalDevice::getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR &&
+                       "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
+#  endif
 
     std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains( timeDomainKHRAllocator );
     uint32_t                                                                 timeDomainCount;
@@ -23540,6 +26173,10 @@ namespace VULKAN_HPP_NAMESPACE
                                         Dispatch const &                                                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR &&
+                       "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
+#  endif
 
     std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
       std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
@@ -23554,14 +26191,17 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Uint64_tAllocator,
             typename Dispatch,
-            typename B0,
-            typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type>
+            typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
     Device::getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
                                         Uint64_tAllocator &                                                                              uint64_tAllocator,
                                         Dispatch const &                                                                                 d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR &&
+                       "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
+#  endif
 
     std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
       std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) );
@@ -23579,6 +26219,10 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR &&
+                       "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
+#  endif
 
     std::pair<uint64_t, uint64_t> data_;
     uint64_t &                    timestamp    = data_.first;
@@ -23607,6 +26251,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                 Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets2KHR && "Function <vkCmdBindDescriptorSets2KHR> requires <VK_KHR_maintenance6>" );
+#  endif
 
     d.vkCmdBindDescriptorSets2KHR( m_commandBuffer, reinterpret_cast<const VkBindDescriptorSetsInfoKHR *>( &bindDescriptorSetsInfo ) );
   }
@@ -23626,6 +26273,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                            Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdPushConstants2KHR && "Function <vkCmdPushConstants2KHR> requires <VK_KHR_maintenance6>" );
+#  endif
 
     d.vkCmdPushConstants2KHR( m_commandBuffer, reinterpret_cast<const VkPushConstantsInfoKHR *>( &pushConstantsInfo ) );
   }
@@ -23645,6 +26295,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSet2KHR && "Function <vkCmdPushDescriptorSet2KHR> requires <VK_KHR_maintenance6>" );
+#  endif
 
     d.vkCmdPushDescriptorSet2KHR( m_commandBuffer, reinterpret_cast<const VkPushDescriptorSetInfoKHR *>( &pushDescriptorSetInfo ) );
   }
@@ -23667,6 +26320,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const &                                                   d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetWithTemplate2KHR && "Function <vkCmdPushDescriptorSetWithTemplate2KHR> requires <VK_KHR_maintenance6>" );
+#  endif
 
     d.vkCmdPushDescriptorSetWithTemplate2KHR( m_commandBuffer,
                                               reinterpret_cast<const VkPushDescriptorSetWithTemplateInfoKHR *>( &pushDescriptorSetWithTemplateInfo ) );
@@ -23689,6 +26345,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                    Dispatch const &                                                d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetDescriptorBufferOffsets2EXT && "Function <vkCmdSetDescriptorBufferOffsets2EXT> requires <VK_KHR_maintenance6>" );
+#  endif
 
     d.vkCmdSetDescriptorBufferOffsets2EXT( m_commandBuffer, reinterpret_cast<const VkSetDescriptorBufferOffsetsInfoEXT *>( &setDescriptorBufferOffsetsInfo ) );
   }
@@ -23711,6 +26370,10 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const &                                                          d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT &&
+                       "Function <vkCmdBindDescriptorBufferEmbeddedSamplers2EXT> requires <VK_KHR_maintenance6>" );
+#  endif
 
     d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(
       m_commandBuffer, reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *>( &bindDescriptorBufferEmbeddedSamplersInfo ) );
diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp
index d208376..d1f6ba1 100644
--- a/include/vulkan/vulkan_handles.hpp
+++ b/include/vulkan/vulkan_handles.hpp
@@ -1065,9 +1065,17 @@ namespace VULKAN_HPP_NAMESPACE
   //=== VK_AMD_device_coherent_memory ===
   struct PhysicalDeviceCoherentMemoryFeaturesAMD;
 
+  //=== VK_KHR_dynamic_rendering_local_read ===
+  struct PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;
+  struct RenderingAttachmentLocationInfoKHR;
+  struct RenderingInputAttachmentIndexInfoKHR;
+
   //=== VK_EXT_shader_image_atomic_int64 ===
   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
 
+  //=== VK_KHR_shader_quad_control ===
+  struct PhysicalDeviceShaderQuadControlFeaturesKHR;
+
   //=== VK_EXT_memory_budget ===
   struct PhysicalDeviceMemoryBudgetPropertiesEXT;
 
@@ -1123,17 +1131,9 @@ namespace VULKAN_HPP_NAMESPACE
   //=== VK_EXT_headless_surface ===
   struct HeadlessSurfaceCreateInfoEXT;
 
-  //=== VK_EXT_line_rasterization ===
-  struct PhysicalDeviceLineRasterizationFeaturesEXT;
-  struct PhysicalDeviceLineRasterizationPropertiesEXT;
-  struct PipelineRasterizationLineStateCreateInfoEXT;
-
   //=== VK_EXT_shader_atomic_float ===
   struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
 
-  //=== VK_EXT_index_type_uint8 ===
-  struct PhysicalDeviceIndexTypeUint8FeaturesEXT;
-
   //=== VK_EXT_extended_dynamic_state ===
   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
 
@@ -1520,6 +1520,9 @@ namespace VULKAN_HPP_NAMESPACE
   //=== VK_ARM_shader_core_properties ===
   struct PhysicalDeviceShaderCorePropertiesARM;
 
+  //=== VK_KHR_shader_subgroup_rotate ===
+  struct PhysicalDeviceShaderSubgroupRotateFeaturesKHR;
+
   //=== VK_ARM_scheduling_controls ===
   struct DeviceQueueShaderCoreControlCreateInfoARM;
   struct PhysicalDeviceSchedulingControlsFeaturesARM;
@@ -1572,6 +1575,9 @@ namespace VULKAN_HPP_NAMESPACE
   //=== VK_NV_linear_color_attachment ===
   struct PhysicalDeviceLinearColorAttachmentFeaturesNV;
 
+  //=== VK_KHR_shader_maximal_reconvergence ===
+  struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
+
   //=== VK_EXT_image_compression_control_swapchain ===
   struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
 
@@ -1754,6 +1760,9 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceVertexAttributeDivisorFeaturesKHR;
   using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeaturesKHR;
 
+  //=== VK_KHR_shader_float_controls2 ===
+  struct PhysicalDeviceShaderFloatControls2FeaturesKHR;
+
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
   //=== VK_QNX_external_memory_screen_buffer ===
   struct ScreenBufferPropertiesQNX;
@@ -1766,10 +1775,25 @@ namespace VULKAN_HPP_NAMESPACE
   //=== VK_MSFT_layered_driver ===
   struct PhysicalDeviceLayeredDriverPropertiesMSFT;
 
+  //=== VK_KHR_index_type_uint8 ===
+  struct PhysicalDeviceIndexTypeUint8FeaturesKHR;
+  using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8FeaturesKHR;
+
+  //=== VK_KHR_line_rasterization ===
+  struct PhysicalDeviceLineRasterizationFeaturesKHR;
+  using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeaturesKHR;
+  struct PhysicalDeviceLineRasterizationPropertiesKHR;
+  using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationPropertiesKHR;
+  struct PipelineRasterizationLineStateCreateInfoKHR;
+  using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfoKHR;
+
   //=== VK_KHR_calibrated_timestamps ===
   struct CalibratedTimestampInfoKHR;
   using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR;
 
+  //=== VK_KHR_shader_expect_assume ===
+  struct PhysicalDeviceShaderExpectAssumeFeaturesKHR;
+
   //=== VK_KHR_maintenance6 ===
   struct PhysicalDeviceMaintenance6FeaturesKHR;
   struct PhysicalDeviceMaintenance6PropertiesKHR;
@@ -5761,6 +5785,26 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 
+    //=== VK_KHR_dynamic_rendering_local_read ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR * pLocationInfo,
+                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR & locationInfo,
+                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR * pLocationInfo,
+                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR & locationInfo,
+                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
     //=== VK_EXT_line_rasterization ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -6307,10 +6351,6 @@ namespace VULKAN_HPP_NAMESPACE
     //=== VK_EXT_extended_dynamic_state3 ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin,
-                                         Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable,
                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
@@ -6382,6 +6422,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin,
+                                         Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -6524,6 +6568,13 @@ namespace VULKAN_HPP_NAMESPACE
     void setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask,
                                              Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
+    //=== VK_KHR_line_rasterization ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setLineStippleKHR( uint32_t           lineStippleFactor,
+                            uint16_t           lineStipplePattern,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
     //=== VK_KHR_maintenance6 ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -8677,10 +8728,10 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
                          getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
-              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                        = CheckpointDataNVAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV>::value, int>::type = 0>
+    template <
+      typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
+      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
       getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -8722,10 +8773,10 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
                          getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
-              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                         = CheckpointData2NVAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV>::value, int>::type = 0>
+    template <
+      typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
+      typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
       getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -9018,8 +9069,9 @@ namespace VULKAN_HPP_NAMESPACE
       getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,
               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                     = SparseImageMemoryRequirementsAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
                          getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,
                                                            SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
@@ -9559,10 +9611,9 @@ namespace VULKAN_HPP_NAMESPACE
     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
-              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                                                               = Uint8_tAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
+    template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
+              typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
                             Uint8_tAllocator &                  uint8_tAllocator,
@@ -9598,8 +9649,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B0                = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
                                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
@@ -9620,10 +9670,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
                                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
-              typename B0                = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type = 0>
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
+              typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
                          createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
                                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
@@ -9655,8 +9705,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B0                = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
                                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
@@ -9677,10 +9726,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
-              typename B0                = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type = 0>
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
+              typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
                          createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
@@ -9909,8 +9958,7 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>,
               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B0                     = DescriptorSetAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
                               DescriptorSetAllocator &                                descriptorSetAllocator,
@@ -9921,10 +9969,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>,
-              typename B0                     = DescriptorSetAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>::value, int>::type = 0>
+    template <
+      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename DescriptorSetAllocator    = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>,
+      typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>::value,
+                              int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
                                     DescriptorSetAllocator &                                descriptorSetAllocator,
@@ -10129,8 +10178,7 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>,
               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B0                     = CommandBufferAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
                               CommandBufferAllocator &                                commandBufferAllocator,
@@ -10141,10 +10189,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>,
-              typename B0                     = CommandBufferAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>::value, int>::type = 0>
+    template <
+      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename CommandBufferAllocator    = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>,
+      typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>::value,
+                              int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
                                     CommandBufferAllocator &                                commandBufferAllocator,
@@ -10258,8 +10307,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                             Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                      = SparseImageMemoryRequirements2Allocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
                          getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
                                                             SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
@@ -10595,8 +10645,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                            Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                      = SparseImageMemoryRequirements2Allocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
                          getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
                                                            SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,
@@ -10658,8 +10709,7 @@ namespace VULKAN_HPP_NAMESPACE
       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>,
               typename Dispatch       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1             = ImageAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::Image>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename ImageAllocator::value_type, VULKAN_HPP_NAMESPACE::Image>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type getSwapchainImagesKHR(
       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -10725,8 +10775,7 @@ namespace VULKAN_HPP_NAMESPACE
                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>,
               typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B0                    = SwapchainKHRAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
       createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                    allocator,
@@ -10744,10 +10793,11 @@ namespace VULKAN_HPP_NAMESPACE
       createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>,
-              typename B0                    = SwapchainKHRAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::value, int>::type = 0>
+    template <
+      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename SwapchainKHRAllocator     = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>,
+      typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::value,
+                              int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
       createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                    allocator,
@@ -10841,8 +10891,9 @@ namespace VULKAN_HPP_NAMESPACE
                                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,
               typename Dispatch                                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                         = VideoSessionMemoryRequirementsKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR        videoSession,
@@ -11040,10 +11091,9 @@ namespace VULKAN_HPP_NAMESPACE
                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
-              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                                                               = Uint8_tAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
+    template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
+              typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
@@ -11327,8 +11377,9 @@ namespace VULKAN_HPP_NAMESPACE
       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,
               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                    = PastPresentationTimingGOOGLEAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
                                        PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
@@ -11515,8 +11566,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B0                = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                          createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
@@ -11538,10 +11588,10 @@ namespace VULKAN_HPP_NAMESPACE
                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
-              typename B0                = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type = 0>
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
+              typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
                          createExecutionGraphPipelinesAMDXUnique(
                            VULKAN_HPP_NAMESPACE::PipelineCache                                                                        pipelineCache,
@@ -11629,8 +11679,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                      = SparseImageMemoryRequirements2Allocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
                          getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
                                                                SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
@@ -11812,8 +11863,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B0                = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                          createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,
                                                        VULKAN_HPP_NAMESPACE::PipelineCache                                                                   pipelineCache,
@@ -11837,10 +11887,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
                                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                                                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
-              typename B0                = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type = 0>
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
+              typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
                          createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
                                                              VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,
@@ -12040,10 +12090,9 @@ namespace VULKAN_HPP_NAMESPACE
     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
-              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                                                               = Uint8_tAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
+    template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
+              typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
                                  Uint8_tAllocator &                       uint8_tAllocator,
@@ -12136,8 +12185,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B0                = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                          createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
@@ -12158,10 +12206,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
-              typename B0                = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type = 0>
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
+              typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
                          createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
@@ -12268,10 +12316,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
       getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint64_tAllocator                                                                 = std::allocator<uint64_t>,
-              typename Dispatch                                                                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B0                                                                                = Uint64_tAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type = 0>
+    template <typename Uint64_tAllocator                                                                                = std::allocator<uint64_t>,
+              typename Dispatch                                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
       getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
                                   Uint64_tAllocator &                                                                              uint64_tAllocator,
@@ -12566,8 +12613,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,
               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                       = PipelineExecutablePropertiesKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
       getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
@@ -12589,8 +12637,9 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,
               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                      = PipelineExecutableStatisticKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
       getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
@@ -12611,11 +12660,11 @@ namespace VULKAN_HPP_NAMESPACE
       std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
       getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
                                                        Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
-      typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B1                                                   = PipelineExecutableInternalRepresentationKHRAllocator,
-      typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>::value, int>::type = 0>
+    template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
+              typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type,
+                                                   VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>::value,
+                                      int>::type                            = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<
       std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
       getPipelineExecutableInternalRepresentationsKHR(
@@ -12854,10 +12903,9 @@ namespace VULKAN_HPP_NAMESPACE
       typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
-              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B2                                                                               = Uint8_tAllocator,
-              typename std::enable_if<std::is_same<typename B2::value_type, uint8_t>::value, int>::type = 0>
+    template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
+              typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
@@ -12874,10 +12922,9 @@ namespace VULKAN_HPP_NAMESPACE
     template <typename X,
               typename Y,
               typename... Z,
-              typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
-              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B2                                                                               = Uint8_tAllocator,
-              typename std::enable_if<std::is_same<typename B2::value_type, uint8_t>::value, int>::type = 0>
+              typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
+              typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
                                            Uint8_tAllocator &                                                   uint8_tAllocator,
@@ -12916,10 +12963,9 @@ namespace VULKAN_HPP_NAMESPACE
     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
       getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
-              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                                                               = Uint8_tAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
+    template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
+              typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getCudaModuleCacheNV(
       VULKAN_HPP_NAMESPACE::CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -13484,8 +13530,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                               Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                      = SparseImageMemoryRequirements2Allocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
                          getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
                                                               SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,
@@ -13688,8 +13735,7 @@ namespace VULKAN_HPP_NAMESPACE
                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>,
               typename Dispatch           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B0                 = ShaderEXTAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>::type
       createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                 allocator,
@@ -13707,10 +13753,10 @@ namespace VULKAN_HPP_NAMESPACE
       createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>,
-              typename B0                 = ShaderEXTAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::value, int>::type = 0>
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename ShaderEXTAllocator        = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>,
+              typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>::type
       createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                 allocator,
@@ -13730,7 +13776,7 @@ namespace VULKAN_HPP_NAMESPACE
                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT                                     shader,
+    void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader                              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -13755,10 +13801,9 @@ namespace VULKAN_HPP_NAMESPACE
     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
       getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
-              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                                                               = Uint8_tAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
+    template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
+              typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderBinaryDataEXT(
       VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -13775,10 +13820,10 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
       getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
-              typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                          = TilePropertiesQCOMAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>::value, int>::type = 0>
+    template <
+      typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
+      typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
       getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
                                         TilePropertiesQCOMAllocator &     tilePropertiesQCOMAllocator,
@@ -13872,10 +13917,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
       getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint64_tAllocator                                                                 = std::allocator<uint64_t>,
-              typename Dispatch                                                                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B0                                                                                = Uint64_tAllocator,
-              typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type = 0>
+    template <typename Uint64_tAllocator                                                                                = std::allocator<uint64_t>,
+              typename Dispatch                                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
       getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
                                   Uint64_tAllocator &                                                                              uint64_tAllocator,
@@ -14118,8 +14162,8 @@ namespace VULKAN_HPP_NAMESPACE
                          getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,
               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                             = QueueFamilyPropertiesAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value,
+                                      int>::type      = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
                          getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
                                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -14165,10 +14209,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
       enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                                           Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
-              typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                           = ExtensionPropertiesAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
+    template <
+      typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
+      typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
       enumerateDeviceExtensionProperties( Optional<const std::string>    layerName,
                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
@@ -14185,8 +14229,7 @@ namespace VULKAN_HPP_NAMESPACE
       enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
               typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                       = LayerPropertiesAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
       enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -14210,10 +14253,11 @@ namespace VULKAN_HPP_NAMESPACE
                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
                                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
-              typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                   = SparseImageFormatPropertiesAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value, int>::type = 0>
+    template <
+      typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
+      typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value,
+                              int>::type            = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
                                                          VULKAN_HPP_NAMESPACE::ImageType           type,
@@ -14289,8 +14333,8 @@ namespace VULKAN_HPP_NAMESPACE
                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                              = QueueFamilyProperties2Allocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value,
+                                      int>::type       = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
                          getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
                                                     Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -14300,10 +14344,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename StructureChain,
-              typename StructureChainAllocator                                                                 = std::allocator<StructureChain>,
-              typename Dispatch                                                                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                                                                      = StructureChainAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
+              typename StructureChainAllocator = std::allocator<StructureChain>,
+              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
       getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -14333,8 +14376,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                           Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                    = SparseImageFormatProperties2Allocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
                          getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
                                                           SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,
@@ -14387,8 +14431,9 @@ namespace VULKAN_HPP_NAMESPACE
       getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                    = PhysicalDeviceToolPropertiesAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
       getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
                          Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -14428,10 +14473,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
                             Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
-              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                        = SurfaceFormatKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value, int>::type = 0>
+    template <
+      typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
+      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                             SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
@@ -14450,8 +14495,7 @@ namespace VULKAN_HPP_NAMESPACE
                                  Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                      = PresentModeKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                                  PresentModeKHRAllocator &        presentModeKHRAllocator,
@@ -14471,8 +14515,7 @@ namespace VULKAN_HPP_NAMESPACE
       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>,
               typename Dispatch        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1              = Rect2DAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::Rect2D>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, VULKAN_HPP_NAMESPACE::Rect2D>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type getPresentRectanglesKHR(
       VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -14490,8 +14533,8 @@ namespace VULKAN_HPP_NAMESPACE
       getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,
               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                            = DisplayPropertiesKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value,
+                                      int>::type     = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
       getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -14506,10 +14549,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
       getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
-              typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                 = DisplayPlanePropertiesKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value, int>::type = 0>
+    template <
+      typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
+      typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value,
+                              int>::type          = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
       getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
                                     Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -14526,8 +14570,7 @@ namespace VULKAN_HPP_NAMESPACE
       getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>,
               typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                  = DisplayKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR(
       uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -14542,10 +14585,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
-              typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                = DisplayModePropertiesKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value, int>::type = 0>
+    template <
+      typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
+      typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value,
+                              int>::type         = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
                                    DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
@@ -14670,10 +14714,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
                                    Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
-              typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                = VideoFormatPropertiesKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>::value, int>::type = 0>
+    template <
+      typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
+      typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>::value,
+                              int>::type         = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
                                    VideoFormatPropertiesKHRAllocator &                            videoFormatPropertiesKHRAllocator,
@@ -14768,8 +14813,8 @@ namespace VULKAN_HPP_NAMESPACE
                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                              = QueueFamilyProperties2Allocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value,
+                                      int>::type       = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
                          getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
                                                        Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -14779,10 +14824,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename StructureChain,
-              typename StructureChainAllocator                                                                 = std::allocator<StructureChain>,
-              typename Dispatch                                                                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                                                                      = StructureChainAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
+              typename StructureChainAllocator = std::allocator<StructureChain>,
+              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
       getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -14812,8 +14856,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                              Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                    = SparseImageFormatProperties2Allocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
                          getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
                                                              SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,
@@ -14931,11 +14976,10 @@ namespace VULKAN_HPP_NAMESPACE
     template <typename PerformanceCounterKHRAllocator            = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,
               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,
               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                        = PerformanceCounterKHRAllocator,
-              typename B2                                        = PerformanceCounterDescriptionKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>::value &&
-                                        std::is_same<typename B2::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>::value,
-                                      int>::type                 = 0>
+              typename std::enable_if<
+                std::is_same<typename PerformanceCounterKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>::value &&
+                  std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
                                          std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
@@ -14984,10 +15028,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
-              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                         = SurfaceFormat2KHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>::value, int>::type = 0>
+    template <
+      typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
+      typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                              SurfaceFormat2KHRAllocator &                                surfaceFormat2KHRAllocator,
@@ -14999,10 +15043,9 @@ namespace VULKAN_HPP_NAMESPACE
       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename StructureChain,
-              typename StructureChainAllocator                                                                 = std::allocator<StructureChain>,
-              typename Dispatch                                                                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                                                                      = StructureChainAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
+              typename StructureChainAllocator = std::allocator<StructureChain>,
+              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                              StructureChainAllocator &                                   structureChainAllocator,
@@ -15022,8 +15065,8 @@ namespace VULKAN_HPP_NAMESPACE
       getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,
               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                             = DisplayProperties2KHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>::value,
+                                      int>::type      = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
       getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -15038,10 +15081,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
       getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
-              typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                  = DisplayPlaneProperties2KHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>::value, int>::type = 0>
+    template <
+      typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
+      typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>::value,
+                              int>::type           = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
       getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
                                      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -15057,10 +15101,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
-              typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                 = DisplayModeProperties2KHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>::value, int>::type = 0>
+    template <
+      typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
+      typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>::value,
+                              int>::type          = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR     display,
                                     DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
@@ -15103,8 +15148,7 @@ namespace VULKAN_HPP_NAMESPACE
       getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                     = TimeDomainKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
       getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -15123,8 +15167,9 @@ namespace VULKAN_HPP_NAMESPACE
       getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,
               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                            = PhysicalDeviceFragmentShadingRateKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type,
+                                                   VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>::value,
+                                      int>::type                     = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
       getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
@@ -15144,8 +15189,9 @@ namespace VULKAN_HPP_NAMESPACE
       getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                    = PhysicalDeviceToolPropertiesAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
       getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
                             Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -15165,8 +15211,9 @@ namespace VULKAN_HPP_NAMESPACE
       getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,
               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                     = CooperativeMatrixPropertiesNVAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
       getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
@@ -15188,8 +15235,9 @@ namespace VULKAN_HPP_NAMESPACE
       getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,
               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                            = FramebufferMixedSamplesCombinationNVAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type,
+                                                   VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>::value,
+                                      int>::type                     = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
       getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
@@ -15211,8 +15259,7 @@ namespace VULKAN_HPP_NAMESPACE
                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                      = PresentModeKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                                   PresentModeKHRAllocator &                                   presentModeKHRAllocator,
@@ -15342,8 +15389,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,
               typename Dispatch                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                          = OpticalFlowImageFormatPropertiesNVAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
       getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
@@ -15365,8 +15413,9 @@ namespace VULKAN_HPP_NAMESPACE
       getCooperativeMatrixPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>,
               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                      = CooperativeMatrixPropertiesKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
       getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator,
@@ -15385,8 +15434,7 @@ namespace VULKAN_HPP_NAMESPACE
       getCalibrateableTimeDomainsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                     = TimeDomainKHRAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
       getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -15497,8 +15545,7 @@ namespace VULKAN_HPP_NAMESPACE
       enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>,
               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                      = PhysicalDeviceAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice>::value, int>::type = 0>
+              typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type
       enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -15524,8 +15571,9 @@ namespace VULKAN_HPP_NAMESPACE
       enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                     = PhysicalDeviceGroupPropertiesAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
       enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
@@ -15825,8 +15873,9 @@ namespace VULKAN_HPP_NAMESPACE
       enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B1                                     = PhysicalDeviceGroupPropertiesAllocator,
-              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value, int>::type = 0>
+              typename std::enable_if<
+                std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,
+                int>::type = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
       enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
@@ -16126,10 +16175,10 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
     enumerateInstanceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                                           Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
-  template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
-            typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-            typename B1                           = ExtensionPropertiesAllocator,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
+  template <
+    typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
+    typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+    typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
     enumerateInstanceExtensionProperties( Optional<const std::string>    layerName,
                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
@@ -16146,8 +16195,7 @@ namespace VULKAN_HPP_NAMESPACE
     enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
   template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
             typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-            typename B1                       = LayerPropertiesAllocator,
-            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
+            typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
     enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
diff --git a/include/vulkan/vulkan_hash.hpp b/include/vulkan/vulkan_hash.hpp
index fd846f5..91e97fd 100644
--- a/include/vulkan/vulkan_hash.hpp
+++ b/include/vulkan/vulkan_hash.hpp
@@ -8356,6 +8356,21 @@ namespace std
   };
 
   template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const & physicalDeviceDynamicRenderingLocalReadFeaturesKHR ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeaturesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeaturesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeaturesKHR.dynamicRenderingLocalRead );
+      return seed;
+    }
+  };
+
+  template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>
   {
     std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const &
@@ -9282,15 +9297,15 @@ namespace std
   };
 
   template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR>
   {
     std::size_t
-      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const & physicalDeviceIndexTypeUint8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR const & physicalDeviceIndexTypeUint8FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
     {
       std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.sType );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.indexTypeUint8 );
       return seed;
     }
   };
@@ -9519,34 +9534,34 @@ namespace std
   };
 
   template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR>
   {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const & physicalDeviceLineRasterizationFeaturesEXT ) const
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR const & physicalDeviceLineRasterizationFeaturesKHR ) const
       VULKAN_HPP_NOEXCEPT
     {
       std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.sType );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.rectangularLines );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.smoothLines );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.rectangularLines );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.bresenhamLines );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.smoothLines );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledRectangularLines );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledBresenhamLines );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledSmoothLines );
       return seed;
     }
   };
 
   template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR>
   {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const & physicalDeviceLineRasterizationPropertiesEXT ) const
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR const & physicalDeviceLineRasterizationPropertiesKHR ) const
       VULKAN_HPP_NOEXCEPT
     {
       std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.sType );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.lineSubPixelPrecisionBits );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.lineSubPixelPrecisionBits );
       return seed;
     }
   };
@@ -11180,6 +11195,20 @@ namespace std
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR const & physicalDeviceShaderExpectAssumeFeaturesKHR ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeaturesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeaturesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeaturesKHR.shaderExpectAssume );
+      return seed;
+    }
+  };
+
+  template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features>
   {
     std::size_t
@@ -11195,6 +11224,20 @@ namespace std
   };
 
   template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR const & physicalDeviceShaderFloatControls2FeaturesKHR ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2FeaturesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2FeaturesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2FeaturesKHR.shaderFloatControls2 );
+      return seed;
+    }
+  };
+
+  template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
   {
     std::size_t operator()(
@@ -11297,6 +11340,21 @@ namespace std
   };
 
   template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & physicalDeviceShaderMaximalReconvergenceFeaturesKHR ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.shaderMaximalReconvergence );
+      return seed;
+    }
+  };
+
+  template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT>
   {
     std::size_t operator()(
@@ -11360,6 +11418,20 @@ namespace std
   };
 
   template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR const & physicalDeviceShaderQuadControlFeaturesKHR ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.shaderQuadControl );
+      return seed;
+    }
+  };
+
+  template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV>
   {
     std::size_t
@@ -11403,6 +11475,21 @@ namespace std
   };
 
   template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR const & physicalDeviceShaderSubgroupRotateFeaturesKHR ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.shaderSubgroupRotate );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.shaderSubgroupRotateClustered );
+      return seed;
+    }
+  };
+
+  template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>
   {
     std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &
@@ -12688,18 +12775,18 @@ namespace std
   };
 
   template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>
+  struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR>
   {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const & pipelineRasterizationLineStateCreateInfoEXT ) const
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR const & pipelineRasterizationLineStateCreateInfoKHR ) const
       VULKAN_HPP_NOEXCEPT
     {
       std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.sType );
-      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineRasterizationMode );
-      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.stippledLineEnable );
-      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStippleFactor );
-      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStipplePattern );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineRasterizationMode );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.stippledLineEnable );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineStippleFactor );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineStipplePattern );
       return seed;
     }
   };
@@ -13915,6 +14002,20 @@ namespace std
   };
 
   template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR const & renderingAttachmentLocationInfoKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.colorAttachmentCount );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.pColorAttachmentLocations );
+      return seed;
+    }
+  };
+
+  template <>
   struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
   {
     std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const & renderingFragmentDensityMapAttachmentInfoEXT ) const
@@ -13966,6 +14067,22 @@ namespace std
   };
 
   template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR const & renderingInputAttachmentIndexInfoKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.colorAttachmentCount );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pColorAttachmentInputIndices );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pDepthInputAttachmentIndex );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pStencilInputAttachmentIndex );
+      return seed;
+    }
+  };
+
+  template <>
   struct hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2>
   {
     std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 const & resolveImageInfo2 ) const VULKAN_HPP_NOEXCEPT
diff --git a/include/vulkan/vulkan_raii.hpp b/include/vulkan/vulkan_raii.hpp
index 49af076..e97bfb3 100644
--- a/include/vulkan/vulkan_raii.hpp
+++ b/include/vulkan/vulkan_raii.hpp
@@ -1267,6 +1267,12 @@ namespace VULKAN_HPP_NAMESPACE
         //=== VK_KHR_fragment_shading_rate ===
         vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) );
 
+        //=== VK_KHR_dynamic_rendering_local_read ===
+        vkCmdSetRenderingAttachmentLocationsKHR =
+          PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocationsKHR" ) );
+        vkCmdSetRenderingInputAttachmentIndicesKHR =
+          PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) );
+
         //=== VK_EXT_buffer_device_address ===
         vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) );
         if ( !vkGetBufferDeviceAddress )
@@ -1297,6 +1303,8 @@ namespace VULKAN_HPP_NAMESPACE
 
         //=== VK_EXT_line_rasterization ===
         vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
+        if ( !vkCmdSetLineStippleKHR )
+          vkCmdSetLineStippleKHR = vkCmdSetLineStippleEXT;
 
         //=== VK_EXT_host_query_reset ===
         vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) );
@@ -1617,7 +1625,6 @@ namespace VULKAN_HPP_NAMESPACE
           PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectDeviceAddressNV" ) );
 
         //=== VK_EXT_extended_dynamic_state3 ===
-        vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) );
         vkCmdSetDepthClampEnableEXT         = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) );
         vkCmdSetPolygonModeEXT              = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) );
         vkCmdSetRasterizationSamplesEXT     = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) );
@@ -1628,6 +1635,7 @@ namespace VULKAN_HPP_NAMESPACE
         vkCmdSetColorBlendEnableEXT         = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) );
         vkCmdSetColorBlendEquationEXT       = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) );
         vkCmdSetColorWriteMaskEXT           = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) );
+        vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) );
         vkCmdSetRasterizationStreamEXT      = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) );
         vkCmdSetConservativeRasterizationModeEXT =
           PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) );
@@ -1699,6 +1707,9 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) );
 #  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
+        //=== VK_KHR_line_rasterization ===
+        vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleKHR" ) );
+
         //=== VK_KHR_calibrated_timestamps ===
         vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) );
 
@@ -2234,6 +2245,10 @@ namespace VULKAN_HPP_NAMESPACE
       //=== VK_KHR_fragment_shading_rate ===
       PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0;
 
+      //=== VK_KHR_dynamic_rendering_local_read ===
+      PFN_vkCmdSetRenderingAttachmentLocationsKHR    vkCmdSetRenderingAttachmentLocationsKHR    = 0;
+      PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR = 0;
+
       //=== VK_EXT_buffer_device_address ===
       PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0;
 
@@ -2501,7 +2516,6 @@ namespace VULKAN_HPP_NAMESPACE
       PFN_vkGetPipelineIndirectDeviceAddressNV      vkGetPipelineIndirectDeviceAddressNV      = 0;
 
       //=== VK_EXT_extended_dynamic_state3 ===
-      PFN_vkCmdSetTessellationDomainOriginEXT         vkCmdSetTessellationDomainOriginEXT         = 0;
       PFN_vkCmdSetDepthClampEnableEXT                 vkCmdSetDepthClampEnableEXT                 = 0;
       PFN_vkCmdSetPolygonModeEXT                      vkCmdSetPolygonModeEXT                      = 0;
       PFN_vkCmdSetRasterizationSamplesEXT             vkCmdSetRasterizationSamplesEXT             = 0;
@@ -2512,6 +2526,7 @@ namespace VULKAN_HPP_NAMESPACE
       PFN_vkCmdSetColorBlendEnableEXT                 vkCmdSetColorBlendEnableEXT                 = 0;
       PFN_vkCmdSetColorBlendEquationEXT               vkCmdSetColorBlendEquationEXT               = 0;
       PFN_vkCmdSetColorWriteMaskEXT                   vkCmdSetColorWriteMaskEXT                   = 0;
+      PFN_vkCmdSetTessellationDomainOriginEXT         vkCmdSetTessellationDomainOriginEXT         = 0;
       PFN_vkCmdSetRasterizationStreamEXT              vkCmdSetRasterizationStreamEXT              = 0;
       PFN_vkCmdSetConservativeRasterizationModeEXT    vkCmdSetConservativeRasterizationModeEXT    = 0;
       PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT = 0;
@@ -2576,6 +2591,9 @@ namespace VULKAN_HPP_NAMESPACE
       PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder                    = 0;
 #  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
+      //=== VK_KHR_line_rasterization ===
+      PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0;
+
       //=== VK_KHR_calibrated_timestamps ===
       PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR = 0;
 
@@ -2833,6 +2851,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_instance;
       }
 
+      operator VULKAN_HPP_NAMESPACE::Instance() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_instance;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_instance )
@@ -3100,6 +3123,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_physicalDevice;
       }
 
+      operator VULKAN_HPP_NAMESPACE::PhysicalDevice() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_physicalDevice;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         m_physicalDevice = nullptr;
@@ -3561,6 +3589,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_device;
       }
 
+      operator VULKAN_HPP_NAMESPACE::Device() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_device;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_device )
@@ -4584,7 +4617,7 @@ namespace VULKAN_HPP_NAMESPACE
       AccelerationStructureKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                                 VkAccelerationStructureKHR                                                      accelerationStructure,
                                 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_accelerationStructure( accelerationStructure )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -4628,6 +4661,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_accelerationStructure;
       }
 
+      operator VULKAN_HPP_NAMESPACE::AccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_accelerationStructure;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_accelerationStructure )
@@ -4699,7 +4737,7 @@ namespace VULKAN_HPP_NAMESPACE
       AccelerationStructureNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                                VkAccelerationStructureNV                                                       accelerationStructure,
                                VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_accelerationStructure( accelerationStructure )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -4743,6 +4781,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_accelerationStructure;
       }
 
+      operator VULKAN_HPP_NAMESPACE::AccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_accelerationStructure;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_accelerationStructure )
@@ -4822,7 +4865,7 @@ namespace VULKAN_HPP_NAMESPACE
       Buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
               VkBuffer                                                                        buffer,
               VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_buffer( buffer )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -4866,6 +4909,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_buffer;
       }
 
+      operator VULKAN_HPP_NAMESPACE::Buffer() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_buffer;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_buffer )
@@ -4943,7 +4991,7 @@ namespace VULKAN_HPP_NAMESPACE
       BufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                                VkBufferCollectionFUCHSIA                                                       collection,
                                VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_collection( collection )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -4987,6 +5035,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_collection;
       }
 
+      operator VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_collection;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_collection )
@@ -5067,7 +5120,7 @@ namespace VULKAN_HPP_NAMESPACE
       BufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                   VkBufferView                                                                    bufferView,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_bufferView( bufferView )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -5111,6 +5164,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_bufferView;
       }
 
+      operator VULKAN_HPP_NAMESPACE::BufferView() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_bufferView;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_bufferView )
@@ -5181,7 +5239,7 @@ namespace VULKAN_HPP_NAMESPACE
       CommandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                    VkCommandPool                                                                   commandPool,
                    VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_commandPool( commandPool )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -5225,6 +5283,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_commandPool;
       }
 
+      operator VULKAN_HPP_NAMESPACE::CommandPool() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_commandPool;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_commandPool )
@@ -5296,7 +5359,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     public:
       CommandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkCommandBuffer commandBuffer, VkCommandPool commandPool )
-        : m_device( *device ), m_commandPool( commandPool ), m_commandBuffer( commandBuffer ), m_dispatcher( device.getDispatcher() )
+        : m_device( device ), m_commandPool( commandPool ), m_commandBuffer( commandBuffer ), m_dispatcher( device.getDispatcher() )
       {
       }
 
@@ -5337,6 +5400,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_commandBuffer;
       }
 
+      operator VULKAN_HPP_NAMESPACE::CommandBuffer() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_commandBuffer;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_commandBuffer )
@@ -5966,6 +6034,12 @@ namespace VULKAN_HPP_NAMESPACE
       void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D &                       fragmentSize,
                                       const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT;
 
+      //=== VK_KHR_dynamic_rendering_local_read ===
+
+      void setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR & locationInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR & locationInfo ) const VULKAN_HPP_NOEXCEPT;
+
       //=== VK_EXT_line_rasterization ===
 
       void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT;
@@ -6194,8 +6268,6 @@ namespace VULKAN_HPP_NAMESPACE
 
       //=== VK_EXT_extended_dynamic_state3 ===
 
-      void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT;
-
       void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT;
 
       void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT;
@@ -6222,6 +6294,8 @@ namespace VULKAN_HPP_NAMESPACE
                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks ) const
         VULKAN_HPP_NOEXCEPT;
 
+      void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT;
+
       void setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT;
 
       void
@@ -6289,6 +6363,10 @@ namespace VULKAN_HPP_NAMESPACE
       void setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const
         VULKAN_HPP_NOEXCEPT;
 
+      //=== VK_KHR_line_rasterization ===
+
+      void setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT;
+
       //=== VK_KHR_maintenance6 ===
 
       void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT;
@@ -6362,7 +6440,7 @@ namespace VULKAN_HPP_NAMESPACE
       CuFunctionNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                      VkCuFunctionNVX                                                                 function,
                      VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_function( function )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -6406,6 +6484,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_function;
       }
 
+      operator VULKAN_HPP_NAMESPACE::CuFunctionNVX() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_function;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_function )
@@ -6476,7 +6559,7 @@ namespace VULKAN_HPP_NAMESPACE
       CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                    VkCuModuleNVX                                                                   module,
                    VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_module( module )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -6520,6 +6603,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_module;
       }
 
+      operator VULKAN_HPP_NAMESPACE::CuModuleNVX() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_module;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_module )
@@ -6591,7 +6679,7 @@ namespace VULKAN_HPP_NAMESPACE
       CudaFunctionNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                       VkCudaFunctionNV                                                                function,
                       VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_function( function )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -6635,6 +6723,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_function;
       }
 
+      operator VULKAN_HPP_NAMESPACE::CudaFunctionNV() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_function;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_function )
@@ -6707,7 +6800,7 @@ namespace VULKAN_HPP_NAMESPACE
       CudaModuleNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                     VkCudaModuleNV                                                                  module,
                     VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_module( module )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -6751,6 +6844,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_module;
       }
 
+      operator VULKAN_HPP_NAMESPACE::CudaModuleNV() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_module;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_module )
@@ -6826,7 +6924,7 @@ namespace VULKAN_HPP_NAMESPACE
       DebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                               VkDebugReportCallbackEXT                                                        callback,
                               VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( *instance )
+        : m_instance( instance )
         , m_callback( callback )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
@@ -6870,6 +6968,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_callback;
       }
 
+      operator VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_callback;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_callback )
@@ -6941,7 +7044,7 @@ namespace VULKAN_HPP_NAMESPACE
       DebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                               VkDebugUtilsMessengerEXT                                                        messenger,
                               VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( *instance )
+        : m_instance( instance )
         , m_messenger( messenger )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
@@ -6985,6 +7088,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_messenger;
       }
 
+      operator VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_messenger;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_messenger )
@@ -7055,7 +7163,7 @@ namespace VULKAN_HPP_NAMESPACE
       DeferredOperationKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                             VkDeferredOperationKHR                                                          operation,
                             VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_operation( operation )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -7099,6 +7207,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_operation;
       }
 
+      operator VULKAN_HPP_NAMESPACE::DeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_operation;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_operation )
@@ -7178,7 +7291,7 @@ namespace VULKAN_HPP_NAMESPACE
       DescriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                       VkDescriptorPool                                                                descriptorPool,
                       VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_descriptorPool( descriptorPool )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -7222,6 +7335,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_descriptorPool;
       }
 
+      operator VULKAN_HPP_NAMESPACE::DescriptorPool() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_descriptorPool;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_descriptorPool )
@@ -7286,7 +7404,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     public:
       DescriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkDescriptorSet descriptorSet, VkDescriptorPool descriptorPool )
-        : m_device( *device ), m_descriptorPool( descriptorPool ), m_descriptorSet( descriptorSet ), m_dispatcher( device.getDispatcher() )
+        : m_device( device ), m_descriptorPool( descriptorPool ), m_descriptorSet( descriptorSet ), m_dispatcher( device.getDispatcher() )
       {
       }
 
@@ -7327,6 +7445,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_descriptorSet;
       }
 
+      operator VULKAN_HPP_NAMESPACE::DescriptorSet() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_descriptorSet;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_descriptorSet )
@@ -7439,7 +7562,7 @@ namespace VULKAN_HPP_NAMESPACE
       DescriptorSetLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                            VkDescriptorSetLayout                                                           descriptorSetLayout,
                            VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_descriptorSetLayout( descriptorSetLayout )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -7483,6 +7606,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_descriptorSetLayout;
       }
 
+      operator VULKAN_HPP_NAMESPACE::DescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_descriptorSetLayout;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_descriptorSetLayout )
@@ -7560,7 +7688,7 @@ namespace VULKAN_HPP_NAMESPACE
       DescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                                 VkDescriptorUpdateTemplate                                                      descriptorUpdateTemplate,
                                 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_descriptorUpdateTemplate( descriptorUpdateTemplate )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -7604,6 +7732,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_descriptorUpdateTemplate;
       }
 
+      operator VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_descriptorUpdateTemplate;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_descriptorUpdateTemplate )
@@ -7675,7 +7808,7 @@ namespace VULKAN_HPP_NAMESPACE
       DeviceMemory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                     VkDeviceMemory                                                                  memory,
                     VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_memory( memory )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -7719,6 +7852,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_memory;
       }
 
+      operator VULKAN_HPP_NAMESPACE::DeviceMemory() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_memory;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_memory )
@@ -7823,7 +7961,7 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif
 
       DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, VkDisplayKHR display )
-        : m_physicalDevice( *physicalDevice ), m_display( display ), m_dispatcher( physicalDevice.getDispatcher() )
+        : m_physicalDevice( physicalDevice ), m_display( display ), m_dispatcher( physicalDevice.getDispatcher() )
       {
       }
 
@@ -7862,6 +8000,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_display;
       }
 
+      operator VULKAN_HPP_NAMESPACE::DisplayKHR() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_display;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_display )
@@ -8014,6 +8157,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_displayModeKHR;
       }
 
+      operator VULKAN_HPP_NAMESPACE::DisplayModeKHR() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_displayModeKHR;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         m_physicalDevice = nullptr;
@@ -8074,7 +8222,7 @@ namespace VULKAN_HPP_NAMESPACE
       Event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
              VkEvent                                                                         event,
              VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_event( event )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -8118,6 +8266,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_event;
       }
 
+      operator VULKAN_HPP_NAMESPACE::Event() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_event;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_event )
@@ -8215,7 +8368,7 @@ namespace VULKAN_HPP_NAMESPACE
       Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
              VkFence                                                                         fence,
              VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_fence( fence )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -8259,6 +8412,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_fence;
       }
 
+      operator VULKAN_HPP_NAMESPACE::Fence() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_fence;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_fence )
@@ -8333,7 +8491,7 @@ namespace VULKAN_HPP_NAMESPACE
       Framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                    VkFramebuffer                                                                   framebuffer,
                    VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_framebuffer( framebuffer )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -8377,6 +8535,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_framebuffer;
       }
 
+      operator VULKAN_HPP_NAMESPACE::Framebuffer() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_framebuffer;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_framebuffer )
@@ -8451,7 +8614,7 @@ namespace VULKAN_HPP_NAMESPACE
       Image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
              VkImage                                                                         image,
              VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_image( image )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -8495,6 +8658,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_image;
       }
 
+      operator VULKAN_HPP_NAMESPACE::Image() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_image;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_image )
@@ -8598,7 +8766,7 @@ namespace VULKAN_HPP_NAMESPACE
       ImageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                  VkImageView                                                                     imageView,
                  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_imageView( imageView )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -8642,6 +8810,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_imageView;
       }
 
+      operator VULKAN_HPP_NAMESPACE::ImageView() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_imageView;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_imageView )
@@ -8716,7 +8889,7 @@ namespace VULKAN_HPP_NAMESPACE
       IndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                                 VkIndirectCommandsLayoutNV                                                      indirectCommandsLayout,
                                 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_indirectCommandsLayout( indirectCommandsLayout )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -8760,6 +8933,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_indirectCommandsLayout;
       }
 
+      operator VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_indirectCommandsLayout;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_indirectCommandsLayout )
@@ -8831,7 +9009,7 @@ namespace VULKAN_HPP_NAMESPACE
       MicromapEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                    VkMicromapEXT                                                                   micromap,
                    VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_micromap( micromap )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -8875,6 +9053,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_micromap;
       }
 
+      operator VULKAN_HPP_NAMESPACE::MicromapEXT() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_micromap;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_micromap )
@@ -8945,7 +9128,7 @@ namespace VULKAN_HPP_NAMESPACE
       OpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                             VkOpticalFlowSessionNV                                                          session,
                             VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_session( session )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -8989,6 +9172,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_session;
       }
 
+      operator VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_session;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_session )
@@ -9063,7 +9251,7 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif
 
       PerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkPerformanceConfigurationINTEL configuration )
-        : m_device( *device ), m_configuration( configuration ), m_dispatcher( device.getDispatcher() )
+        : m_device( device ), m_configuration( configuration ), m_dispatcher( device.getDispatcher() )
       {
       }
 
@@ -9102,6 +9290,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_configuration;
       }
 
+      operator VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_configuration;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_configuration )
@@ -9168,7 +9361,7 @@ namespace VULKAN_HPP_NAMESPACE
       PipelineCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                      VkPipelineCache                                                                 pipelineCache,
                      VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_pipelineCache( pipelineCache )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -9212,6 +9405,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_pipelineCache;
       }
 
+      operator VULKAN_HPP_NAMESPACE::PipelineCache() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_pipelineCache;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_pipelineCache )
@@ -9334,7 +9532,7 @@ namespace VULKAN_HPP_NAMESPACE
                 VkPipeline                                                                      pipeline,
                 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator   = nullptr,
                 VULKAN_HPP_NAMESPACE::Result                                                    successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess )
-        : m_device( *device )
+        : m_device( device )
         , m_pipeline( pipeline )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_constructorSuccessCode( successCode )
@@ -9381,6 +9579,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_pipeline;
       }
 
+      operator VULKAN_HPP_NAMESPACE::Pipeline() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_pipeline;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_pipeline )
@@ -9572,7 +9775,7 @@ namespace VULKAN_HPP_NAMESPACE
       PipelineLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                       VkPipelineLayout                                                                pipelineLayout,
                       VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_pipelineLayout( pipelineLayout )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -9616,6 +9819,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_pipelineLayout;
       }
 
+      operator VULKAN_HPP_NAMESPACE::PipelineLayout() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_pipelineLayout;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_pipelineLayout )
@@ -9687,7 +9895,7 @@ namespace VULKAN_HPP_NAMESPACE
       PrivateDataSlot( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                        VkPrivateDataSlot                                                               privateDataSlot,
                        VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_privateDataSlot( privateDataSlot )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -9731,6 +9939,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_privateDataSlot;
       }
 
+      operator VULKAN_HPP_NAMESPACE::PrivateDataSlot() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_privateDataSlot;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_privateDataSlot )
@@ -9802,7 +10015,7 @@ namespace VULKAN_HPP_NAMESPACE
       QueryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                  VkQueryPool                                                                     queryPool,
                  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_queryPool( queryPool )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -9846,6 +10059,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_queryPool;
       }
 
+      operator VULKAN_HPP_NAMESPACE::QueryPool() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_queryPool;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_queryPool )
@@ -9986,6 +10204,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_queue;
       }
 
+      operator VULKAN_HPP_NAMESPACE::Queue() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_queue;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         m_queue      = nullptr;
@@ -10093,7 +10316,7 @@ namespace VULKAN_HPP_NAMESPACE
       RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                   VkRenderPass                                                                    renderPass,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_renderPass( renderPass )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -10137,6 +10360,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_renderPass;
       }
 
+      operator VULKAN_HPP_NAMESPACE::RenderPass() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_renderPass;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_renderPass )
@@ -10215,7 +10443,7 @@ namespace VULKAN_HPP_NAMESPACE
       Sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                VkSampler                                                                       sampler,
                VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_sampler( sampler )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -10259,6 +10487,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_sampler;
       }
 
+      operator VULKAN_HPP_NAMESPACE::Sampler() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_sampler;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_sampler )
@@ -10329,7 +10562,7 @@ namespace VULKAN_HPP_NAMESPACE
       SamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                               VkSamplerYcbcrConversion                                                        ycbcrConversion,
                               VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_ycbcrConversion( ycbcrConversion )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -10373,6 +10606,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_ycbcrConversion;
       }
 
+      operator VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_ycbcrConversion;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_ycbcrConversion )
@@ -10444,7 +10682,7 @@ namespace VULKAN_HPP_NAMESPACE
       Semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                  VkSemaphore                                                                     semaphore,
                  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_semaphore( semaphore )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -10488,6 +10726,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_semaphore;
       }
 
+      operator VULKAN_HPP_NAMESPACE::Semaphore() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_semaphore;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_semaphore )
@@ -10566,7 +10809,7 @@ namespace VULKAN_HPP_NAMESPACE
       ShaderEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                  VkShaderEXT                                                                     shader,
                  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_shader( shader )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -10610,6 +10853,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_shader;
       }
 
+      operator VULKAN_HPP_NAMESPACE::ShaderEXT() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_shader;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_shader )
@@ -10711,7 +10959,7 @@ namespace VULKAN_HPP_NAMESPACE
       ShaderModule( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                     VkShaderModule                                                                  shaderModule,
                     VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_shaderModule( shaderModule )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -10755,6 +11003,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_shaderModule;
       }
 
+      operator VULKAN_HPP_NAMESPACE::ShaderModule() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_shaderModule;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_shaderModule )
@@ -10981,7 +11234,7 @@ namespace VULKAN_HPP_NAMESPACE
       SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &               instance,
                   VkSurfaceKHR                                                                    surface,
                   VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_instance( *instance )
+        : m_instance( instance )
         , m_surface( surface )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( instance.getDispatcher() )
@@ -11025,6 +11278,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_surface;
       }
 
+      operator VULKAN_HPP_NAMESPACE::SurfaceKHR() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_surface;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_surface )
@@ -11095,7 +11353,7 @@ namespace VULKAN_HPP_NAMESPACE
       SwapchainKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                     VkSwapchainKHR                                                                  swapchain,
                     VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_swapchain( swapchain )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -11139,6 +11397,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_swapchain;
       }
 
+      operator VULKAN_HPP_NAMESPACE::SwapchainKHR() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_swapchain;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_swapchain )
@@ -11285,7 +11548,7 @@ namespace VULKAN_HPP_NAMESPACE
       ValidationCacheEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                           VkValidationCacheEXT                                                            validationCache,
                           VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_validationCache( validationCache )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -11329,6 +11592,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_validationCache;
       }
 
+      operator VULKAN_HPP_NAMESPACE::ValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_validationCache;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_validationCache )
@@ -11406,7 +11674,7 @@ namespace VULKAN_HPP_NAMESPACE
       VideoSessionKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                        VkVideoSessionKHR                                                               videoSession,
                        VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_videoSession( videoSession )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -11450,6 +11718,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_videoSession;
       }
 
+      operator VULKAN_HPP_NAMESPACE::VideoSessionKHR() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_videoSession;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_videoSession )
@@ -11527,7 +11800,7 @@ namespace VULKAN_HPP_NAMESPACE
       VideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &                 device,
                                  VkVideoSessionParametersKHR                                                     videoSessionParameters,
                                  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
-        : m_device( *device )
+        : m_device( device )
         , m_videoSessionParameters( videoSessionParameters )
         , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
         , m_dispatcher( device.getDispatcher() )
@@ -11571,6 +11844,11 @@ namespace VULKAN_HPP_NAMESPACE
         return m_videoSessionParameters;
       }
 
+      operator VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_videoSessionParameters;
+      }
+
       void clear() VULKAN_HPP_NOEXCEPT
       {
         if ( m_videoSessionParameters )
@@ -19252,6 +19530,28 @@ namespace VULKAN_HPP_NAMESPACE
                                                        reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
     }
 
+    //=== VK_KHR_dynamic_rendering_local_read ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR(
+      const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR & locationInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingAttachmentLocationsKHR &&
+                         "Function <vkCmdSetRenderingAttachmentLocationsKHR> requires <VK_KHR_dynamic_rendering_local_read>" );
+
+      getDispatcher()->vkCmdSetRenderingAttachmentLocationsKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                                reinterpret_cast<const VkRenderingAttachmentLocationInfoKHR *>( &locationInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR(
+      const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR & locationInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingInputAttachmentIndicesKHR &&
+                         "Function <vkCmdSetRenderingInputAttachmentIndicesKHR> requires <VK_KHR_dynamic_rendering_local_read>" );
+
+      getDispatcher()->vkCmdSetRenderingInputAttachmentIndicesKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                                   reinterpret_cast<const VkRenderingInputAttachmentIndexInfoKHR *>( &locationInfo ) );
+    }
+
     //=== VK_EXT_buffer_device_address ===
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress
@@ -19520,7 +19820,8 @@ namespace VULKAN_HPP_NAMESPACE
 
     VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEXT && "Function <vkCmdSetLineStippleEXT> requires <VK_EXT_line_rasterization>" );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEXT &&
+                         "Function <vkCmdSetLineStippleEXT> requires <VK_EXT_line_rasterization> or <VK_KHR_line_rasterization>" );
 
       getDispatcher()->vkCmdSetLineStippleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern );
     }
@@ -21675,16 +21976,6 @@ namespace VULKAN_HPP_NAMESPACE
 
     //=== VK_EXT_extended_dynamic_state3 ===
 
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetTessellationDomainOriginEXT &&
-                         "Function <vkCmdSetTessellationDomainOriginEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
-
-      getDispatcher()->vkCmdSetTessellationDomainOriginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                            static_cast<VkTessellationDomainOrigin>( domainOrigin ) );
-    }
-
     VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClampEnableEXT &&
@@ -21792,6 +22083,16 @@ namespace VULKAN_HPP_NAMESPACE
                                                   reinterpret_cast<const VkColorComponentFlags *>( colorWriteMasks.data() ) );
     }
 
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetTessellationDomainOriginEXT &&
+                         "Function <vkCmdSetTessellationDomainOriginEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
+
+      getDispatcher()->vkCmdSetTessellationDomainOriginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                            static_cast<VkTessellationDomainOrigin>( domainOrigin ) );
+    }
+
     VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizationStreamEXT &&
@@ -22457,6 +22758,16 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
+    //=== VK_KHR_line_rasterization ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleKHR &&
+                         "Function <vkCmdSetLineStippleKHR> requires <VK_EXT_line_rasterization> or <VK_KHR_line_rasterization>" );
+
+      getDispatcher()->vkCmdSetLineStippleKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern );
+    }
+
     //=== VK_KHR_calibrated_timestamps ===
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> PhysicalDevice::getCalibrateableTimeDomainsKHR() const
diff --git a/include/vulkan/vulkan_shared.hpp b/include/vulkan/vulkan_shared.hpp
index 0843fe2..8b2697a 100644
--- a/include/vulkan/vulkan_shared.hpp
+++ b/include/vulkan/vulkan_shared.hpp
@@ -182,6 +182,13 @@ namespace VULKAN_HPP_NAMESPACE
       return bool( m_handle );
     }
 
+#  if defined( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST )
+    operator HandleType() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_handle;
+    }
+#  endif
+
     const HandleType * operator->() const VULKAN_HPP_NOEXCEPT
     {
       return &m_handle;
diff --git a/include/vulkan/vulkan_static_assertions.hpp b/include/vulkan/vulkan_static_assertions.hpp
index 368e1cc..880d905 100644
--- a/include/vulkan/vulkan_static_assertions.hpp
+++ b/include/vulkan/vulkan_static_assertions.hpp
@@ -4278,6 +4278,30 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD>::value,
                           "PhysicalDeviceCoherentMemoryFeaturesAMD is not nothrow_move_constructible!" );
 
+//=== VK_KHR_dynamic_rendering_local_read ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR ) ==
+                            sizeof( VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR>::value,
+                          "PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR ) == sizeof( VkRenderingAttachmentLocationInfoKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR>::value,
+                          "RenderingAttachmentLocationInfoKHR is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR ) == sizeof( VkRenderingInputAttachmentIndexInfoKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR>::value,
+                          "RenderingInputAttachmentIndexInfoKHR is not nothrow_move_constructible!" );
+
 //=== VK_EXT_shader_image_atomic_int64 ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT ) ==
@@ -4288,6 +4312,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>::value,
                           "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT is not nothrow_move_constructible!" );
 
+//=== VK_KHR_shader_quad_control ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderQuadControlFeaturesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR>::value,
+                          "PhysicalDeviceShaderQuadControlFeaturesKHR is not nothrow_move_constructible!" );
+
 //=== VK_EXT_memory_budget ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ),
@@ -4485,31 +4518,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Headless
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT>::value,
                           "HeadlessSurfaceCreateInfoEXT is not nothrow_move_constructible!" );
 
-//=== VK_EXT_line_rasterization ===
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ),
-                          "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>::value,
-                          "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>::value,
-                          "PhysicalDeviceLineRasterizationFeaturesEXT is not nothrow_move_constructible!" );
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT ) ==
-                            sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ),
-                          "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>::value,
-                          "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>::value,
-                          "PhysicalDeviceLineRasterizationPropertiesEXT is not nothrow_move_constructible!" );
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT ) ==
-                            sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ),
-                          "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>::value,
-                          "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>::value,
-                          "PipelineRasterizationLineStateCreateInfoEXT is not nothrow_move_constructible!" );
-
 //=== VK_EXT_shader_atomic_float ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT ),
@@ -4519,15 +4527,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT>::value,
                           "PhysicalDeviceShaderAtomicFloatFeaturesEXT is not nothrow_move_constructible!" );
 
-//=== VK_EXT_index_type_uint8 ===
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ),
-                          "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>::value,
-                          "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>::value,
-                          "PhysicalDeviceIndexTypeUint8FeaturesEXT is not nothrow_move_constructible!" );
-
 //=== VK_EXT_extended_dynamic_state ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT ) ==
@@ -6230,6 +6229,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM>::value,
                           "PhysicalDeviceShaderCorePropertiesARM is not nothrow_move_constructible!" );
 
+//=== VK_KHR_shader_subgroup_rotate ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR ) ==
+                            sizeof( VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR>::value,
+                          "PhysicalDeviceShaderSubgroupRotateFeaturesKHR is not nothrow_move_constructible!" );
+
 //=== VK_ARM_scheduling_controls ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM ) == sizeof( VkDeviceQueueShaderCoreControlCreateInfoARM ),
@@ -6468,6 +6477,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>::value,
                           "PhysicalDeviceLinearColorAttachmentFeaturesNV is not nothrow_move_constructible!" );
 
+//=== VK_KHR_shader_maximal_reconvergence ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR ) ==
+                            sizeof( VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>::value,
+                          "PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR is not nothrow_move_constructible!" );
+
 //=== VK_EXT_image_compression_control_swapchain ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT ) ==
@@ -7224,6 +7243,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR>::value,
                           "PhysicalDeviceVertexAttributeDivisorFeaturesKHR is not nothrow_move_constructible!" );
 
+//=== VK_KHR_shader_float_controls2 ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR ) ==
+                            sizeof( VkPhysicalDeviceShaderFloatControls2FeaturesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR>::value,
+                          "PhysicalDeviceShaderFloatControls2FeaturesKHR is not nothrow_move_constructible!" );
+
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
 //=== VK_QNX_external_memory_screen_buffer ===
 
@@ -7268,6 +7297,40 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>::value,
                           "PhysicalDeviceLayeredDriverPropertiesMSFT is not nothrow_move_constructible!" );
 
+//=== VK_KHR_index_type_uint8 ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR>::value,
+                          "PhysicalDeviceIndexTypeUint8FeaturesKHR is not nothrow_move_constructible!" );
+
+//=== VK_KHR_line_rasterization ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR>::value,
+                          "PhysicalDeviceLineRasterizationFeaturesKHR is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR ) ==
+                            sizeof( VkPhysicalDeviceLineRasterizationPropertiesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR>::value,
+                          "PhysicalDeviceLineRasterizationPropertiesKHR is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR ) ==
+                            sizeof( VkPipelineRasterizationLineStateCreateInfoKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR>::value,
+                          "PipelineRasterizationLineStateCreateInfoKHR is not nothrow_move_constructible!" );
+
 //=== VK_KHR_calibrated_timestamps ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR ) == sizeof( VkCalibratedTimestampInfoKHR ),
@@ -7276,6 +7339,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Calibrat
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR>::value,
                           "CalibratedTimestampInfoKHR is not nothrow_move_constructible!" );
 
+//=== VK_KHR_shader_expect_assume ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR ) ==
+                            sizeof( VkPhysicalDeviceShaderExpectAssumeFeaturesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR>::value,
+                          "PhysicalDeviceShaderExpectAssumeFeaturesKHR is not nothrow_move_constructible!" );
+
 //=== VK_KHR_maintenance6 ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance6FeaturesKHR ),
diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp
index 5195828..6a74e2f 100644
--- a/include/vulkan/vulkan_structs.hpp
+++ b/include/vulkan/vulkan_structs.hpp
@@ -1086,35 +1086,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildSizesInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildSizesInfoKHR &
-      setAccelerationStructureSize( VULKAN_HPP_NAMESPACE::DeviceSize accelerationStructureSize_ ) VULKAN_HPP_NOEXCEPT
-    {
-      accelerationStructureSize = accelerationStructureSize_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildSizesInfoKHR &
-      setUpdateScratchSize( VULKAN_HPP_NAMESPACE::DeviceSize updateScratchSize_ ) VULKAN_HPP_NOEXCEPT
-    {
-      updateScratchSize = updateScratchSize_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildSizesInfoKHR &
-      setBuildScratchSize( VULKAN_HPP_NAMESPACE::DeviceSize buildScratchSize_ ) VULKAN_HPP_NOEXCEPT
-    {
-      buildScratchSize = buildScratchSize_;
-      return *this;
-    }
-#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
     operator VkAccelerationStructureBuildSizesInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureBuildSizesInfoKHR *>( this );
@@ -11442,87 +11413,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA & setMemoryTypeBits( uint32_t memoryTypeBits_ ) VULKAN_HPP_NOEXCEPT
-    {
-      memoryTypeBits = memoryTypeBits_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA & setBufferCount( uint32_t bufferCount_ ) VULKAN_HPP_NOEXCEPT
-    {
-      bufferCount = bufferCount_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA & setCreateInfoIndex( uint32_t createInfoIndex_ ) VULKAN_HPP_NOEXCEPT
-    {
-      createInfoIndex = createInfoIndex_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA & setSysmemPixelFormat( uint64_t sysmemPixelFormat_ ) VULKAN_HPP_NOEXCEPT
-    {
-      sysmemPixelFormat = sysmemPixelFormat_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA &
-      setFormatFeatures( VULKAN_HPP_NAMESPACE::FormatFeatureFlags formatFeatures_ ) VULKAN_HPP_NOEXCEPT
-    {
-      formatFeatures = formatFeatures_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA &
-      setSysmemColorSpaceIndex( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceIndex_ ) VULKAN_HPP_NOEXCEPT
-    {
-      sysmemColorSpaceIndex = sysmemColorSpaceIndex_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA &
-      setSamplerYcbcrConversionComponents( VULKAN_HPP_NAMESPACE::ComponentMapping const & samplerYcbcrConversionComponents_ ) VULKAN_HPP_NOEXCEPT
-    {
-      samplerYcbcrConversionComponents = samplerYcbcrConversionComponents_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA &
-      setSuggestedYcbcrModel( VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion suggestedYcbcrModel_ ) VULKAN_HPP_NOEXCEPT
-    {
-      suggestedYcbcrModel = suggestedYcbcrModel_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA &
-      setSuggestedYcbcrRange( VULKAN_HPP_NAMESPACE::SamplerYcbcrRange suggestedYcbcrRange_ ) VULKAN_HPP_NOEXCEPT
-    {
-      suggestedYcbcrRange = suggestedYcbcrRange_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA &
-      setSuggestedXChromaOffset( VULKAN_HPP_NAMESPACE::ChromaLocation suggestedXChromaOffset_ ) VULKAN_HPP_NOEXCEPT
-    {
-      suggestedXChromaOffset = suggestedXChromaOffset_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIA &
-      setSuggestedYChromaOffset( VULKAN_HPP_NAMESPACE::ChromaLocation suggestedYChromaOffset_ ) VULKAN_HPP_NOEXCEPT
-    {
-      suggestedYChromaOffset = suggestedYChromaOffset_;
-      return *this;
-    }
-#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
     operator VkBufferCollectionPropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferCollectionPropertiesFUCHSIA *>( this );
@@ -16629,69 +16519,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesKHR & setMSize( uint32_t MSize_ ) VULKAN_HPP_NOEXCEPT
-    {
-      MSize = MSize_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesKHR & setNSize( uint32_t NSize_ ) VULKAN_HPP_NOEXCEPT
-    {
-      NSize = NSize_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesKHR & setKSize( uint32_t KSize_ ) VULKAN_HPP_NOEXCEPT
-    {
-      KSize = KSize_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesKHR & setAType( VULKAN_HPP_NAMESPACE::ComponentTypeKHR AType_ ) VULKAN_HPP_NOEXCEPT
-    {
-      AType = AType_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesKHR & setBType( VULKAN_HPP_NAMESPACE::ComponentTypeKHR BType_ ) VULKAN_HPP_NOEXCEPT
-    {
-      BType = BType_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesKHR & setCType( VULKAN_HPP_NAMESPACE::ComponentTypeKHR CType_ ) VULKAN_HPP_NOEXCEPT
-    {
-      CType = CType_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesKHR & setResultType( VULKAN_HPP_NAMESPACE::ComponentTypeKHR ResultType_ ) VULKAN_HPP_NOEXCEPT
-    {
-      ResultType = ResultType_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesKHR &
-      setSaturatingAccumulation( VULKAN_HPP_NAMESPACE::Bool32 saturatingAccumulation_ ) VULKAN_HPP_NOEXCEPT
-    {
-      saturatingAccumulation = saturatingAccumulation_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesKHR & setScope( VULKAN_HPP_NAMESPACE::ScopeKHR scope_ ) VULKAN_HPP_NOEXCEPT
-    {
-      scope = scope_;
-      return *this;
-    }
-#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
     operator VkCooperativeMatrixPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCooperativeMatrixPropertiesKHR *>( this );
@@ -16809,62 +16636,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesNV & setMSize( uint32_t MSize_ ) VULKAN_HPP_NOEXCEPT
-    {
-      MSize = MSize_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesNV & setNSize( uint32_t NSize_ ) VULKAN_HPP_NOEXCEPT
-    {
-      NSize = NSize_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesNV & setKSize( uint32_t KSize_ ) VULKAN_HPP_NOEXCEPT
-    {
-      KSize = KSize_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesNV & setAType( VULKAN_HPP_NAMESPACE::ComponentTypeNV AType_ ) VULKAN_HPP_NOEXCEPT
-    {
-      AType = AType_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesNV & setBType( VULKAN_HPP_NAMESPACE::ComponentTypeNV BType_ ) VULKAN_HPP_NOEXCEPT
-    {
-      BType = BType_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesNV & setCType( VULKAN_HPP_NAMESPACE::ComponentTypeNV CType_ ) VULKAN_HPP_NOEXCEPT
-    {
-      CType = CType_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesNV & setDType( VULKAN_HPP_NAMESPACE::ComponentTypeNV DType_ ) VULKAN_HPP_NOEXCEPT
-    {
-      DType = DType_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 CooperativeMatrixPropertiesNV & setScope( VULKAN_HPP_NAMESPACE::ScopeNV scope_ ) VULKAN_HPP_NOEXCEPT
-    {
-      scope = scope_;
-      return *this;
-    }
-#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
     operator VkCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCooperativeMatrixPropertiesNV *>( this );
@@ -27988,38 +27759,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT & setDescription( std::array<char, VK_MAX_DESCRIPTION_SIZE> description_ ) VULKAN_HPP_NOEXCEPT
-    {
-      description = description_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT & setPAddressInfos( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT * pAddressInfos_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pAddressInfos = pAddressInfos_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT & setPVendorInfos( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT * pVendorInfos_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pVendorInfos = pVendorInfos_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT & setPVendorBinaryData( void * pVendorBinaryData_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pVendorBinaryData = pVendorBinaryData_;
-      return *this;
-    }
-#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
     operator VkDeviceFaultInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceFaultInfoEXT *>( this );
@@ -63038,6 +62777,106 @@ namespace VULKAN_HPP_NAMESPACE
 
   using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;
 
+  struct PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR
+  {
+    using NativeType = VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 dynamicRenderingLocalRead_ = {},
+                                                                             void *                       pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , dynamicRenderingLocalRead( dynamicRenderingLocalRead_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR
+      PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR( PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR( VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR( *reinterpret_cast<PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR &
+      operator=( PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR & operator=( VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR &
+      setDynamicRenderingLocalRead( VULKAN_HPP_NAMESPACE::Bool32 dynamicRenderingLocalRead_ ) VULKAN_HPP_NOEXCEPT
+    {
+      dynamicRenderingLocalRead = dynamicRenderingLocalRead_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>( this );
+    }
+
+    operator VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, dynamicRenderingLocalRead );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRenderingLocalRead == rhs.dynamicRenderingLocalRead );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType                     = StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;
+    void *                              pNext                     = {};
+    VULKAN_HPP_NAMESPACE::Bool32        dynamicRenderingLocalRead = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeaturesKHR>
+  {
+    using Type = PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;
+  };
+
   struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
@@ -69583,59 +69422,59 @@ namespace VULKAN_HPP_NAMESPACE
 
   using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
 
-  struct PhysicalDeviceIndexTypeUint8FeaturesEXT
+  struct PhysicalDeviceIndexTypeUint8FeaturesKHR
   {
-    using NativeType = VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
+    using NativeType = VkPhysicalDeviceIndexTypeUint8FeaturesKHR;
 
     static const bool                                  allowDuplicate = false;
-    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesKHR;
 
 #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-    VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 indexTypeUint8_ = {},
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 indexTypeUint8_ = {},
                                                                   void *                       pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
       : pNext( pNext_ )
       , indexTypeUint8( indexTypeUint8_ )
     {
     }
 
-    VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesKHR( PhysicalDeviceIndexTypeUint8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 
-    PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : PhysicalDeviceIndexTypeUint8FeaturesEXT( *reinterpret_cast<PhysicalDeviceIndexTypeUint8FeaturesEXT const *>( &rhs ) )
+    PhysicalDeviceIndexTypeUint8FeaturesKHR( VkPhysicalDeviceIndexTypeUint8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceIndexTypeUint8FeaturesKHR( *reinterpret_cast<PhysicalDeviceIndexTypeUint8FeaturesKHR const *>( &rhs ) )
     {
     }
 
-    PhysicalDeviceIndexTypeUint8FeaturesEXT & operator=( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+    PhysicalDeviceIndexTypeUint8FeaturesKHR & operator=( PhysicalDeviceIndexTypeUint8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
 
-    PhysicalDeviceIndexTypeUint8FeaturesEXT & operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    PhysicalDeviceIndexTypeUint8FeaturesKHR & operator=( VkPhysicalDeviceIndexTypeUint8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const *>( &rhs );
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR const *>( &rhs );
       return *this;
     }
 
 #if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8FeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8FeaturesEXT & setIndexTypeUint8( VULKAN_HPP_NAMESPACE::Bool32 indexTypeUint8_ ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8FeaturesKHR & setIndexTypeUint8( VULKAN_HPP_NAMESPACE::Bool32 indexTypeUint8_ ) VULKAN_HPP_NOEXCEPT
     {
       indexTypeUint8 = indexTypeUint8_;
       return *this;
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceIndexTypeUint8FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>( this );
+      return *reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceIndexTypeUint8FeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>( this );
+      return *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesKHR *>( this );
     }
 
 #if defined( VULKAN_HPP_USE_REFLECT )
@@ -69651,9 +69490,9 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
-    auto operator<=>( PhysicalDeviceIndexTypeUint8FeaturesEXT const & ) const = default;
+    auto operator<=>( PhysicalDeviceIndexTypeUint8FeaturesKHR const & ) const = default;
 #else
-    bool operator==( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator==( PhysicalDeviceIndexTypeUint8FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
 #  if defined( VULKAN_HPP_USE_REFLECT )
       return this->reflect() == rhs.reflect();
@@ -69662,24 +69501,26 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif
     }
 
-    bool operator!=( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator!=( PhysicalDeviceIndexTypeUint8FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
       return !operator==( rhs );
     }
 #endif
 
   public:
-    VULKAN_HPP_NAMESPACE::StructureType sType          = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT;
+    VULKAN_HPP_NAMESPACE::StructureType sType          = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesKHR;
     void *                              pNext          = {};
     VULKAN_HPP_NAMESPACE::Bool32        indexTypeUint8 = {};
   };
 
   template <>
-  struct CppType<StructureType, StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceIndexTypeUint8FeaturesKHR>
   {
-    using Type = PhysicalDeviceIndexTypeUint8FeaturesEXT;
+    using Type = PhysicalDeviceIndexTypeUint8FeaturesKHR;
   };
 
+  using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8FeaturesKHR;
+
   struct PhysicalDeviceInheritedViewportScissorFeaturesNV
   {
     using NativeType = VkPhysicalDeviceInheritedViewportScissorFeaturesNV;
@@ -70937,15 +70778,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeviceSize                  nonCoherentAtomSize                             = {};
   };
 
-  struct PhysicalDeviceLineRasterizationFeaturesEXT
+  struct PhysicalDeviceLineRasterizationFeaturesKHR
   {
-    using NativeType = VkPhysicalDeviceLineRasterizationFeaturesEXT;
+    using NativeType = VkPhysicalDeviceLineRasterizationFeaturesKHR;
 
     static const bool                                  allowDuplicate = false;
-    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceLineRasterizationFeaturesKHR;
 
 #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-    VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 rectangularLines_         = {},
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 rectangularLines_         = {},
                                                                      VULKAN_HPP_NAMESPACE::Bool32 bresenhamLines_           = {},
                                                                      VULKAN_HPP_NAMESPACE::Bool32 smoothLines_              = {},
                                                                      VULKAN_HPP_NAMESPACE::Bool32 stippledRectangularLines_ = {},
@@ -70962,63 +70803,63 @@ namespace VULKAN_HPP_NAMESPACE
     {
     }
 
-    VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesKHR( PhysicalDeviceLineRasterizationFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 
-    PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : PhysicalDeviceLineRasterizationFeaturesEXT( *reinterpret_cast<PhysicalDeviceLineRasterizationFeaturesEXT const *>( &rhs ) )
+    PhysicalDeviceLineRasterizationFeaturesKHR( VkPhysicalDeviceLineRasterizationFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceLineRasterizationFeaturesKHR( *reinterpret_cast<PhysicalDeviceLineRasterizationFeaturesKHR const *>( &rhs ) )
     {
     }
 
-    PhysicalDeviceLineRasterizationFeaturesEXT & operator=( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+    PhysicalDeviceLineRasterizationFeaturesKHR & operator=( PhysicalDeviceLineRasterizationFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
 
-    PhysicalDeviceLineRasterizationFeaturesEXT & operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    PhysicalDeviceLineRasterizationFeaturesKHR & operator=( VkPhysicalDeviceLineRasterizationFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const *>( &rhs );
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR const *>( &rhs );
       return *this;
     }
 
 #if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesEXT &
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesKHR &
       setRectangularLines( VULKAN_HPP_NAMESPACE::Bool32 rectangularLines_ ) VULKAN_HPP_NOEXCEPT
     {
       rectangularLines = rectangularLines_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesEXT & setBresenhamLines( VULKAN_HPP_NAMESPACE::Bool32 bresenhamLines_ ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesKHR & setBresenhamLines( VULKAN_HPP_NAMESPACE::Bool32 bresenhamLines_ ) VULKAN_HPP_NOEXCEPT
     {
       bresenhamLines = bresenhamLines_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesEXT & setSmoothLines( VULKAN_HPP_NAMESPACE::Bool32 smoothLines_ ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesKHR & setSmoothLines( VULKAN_HPP_NAMESPACE::Bool32 smoothLines_ ) VULKAN_HPP_NOEXCEPT
     {
       smoothLines = smoothLines_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesEXT &
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesKHR &
       setStippledRectangularLines( VULKAN_HPP_NAMESPACE::Bool32 stippledRectangularLines_ ) VULKAN_HPP_NOEXCEPT
     {
       stippledRectangularLines = stippledRectangularLines_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesEXT &
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesKHR &
       setStippledBresenhamLines( VULKAN_HPP_NAMESPACE::Bool32 stippledBresenhamLines_ ) VULKAN_HPP_NOEXCEPT
     {
       stippledBresenhamLines = stippledBresenhamLines_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesEXT &
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeaturesKHR &
       setStippledSmoothLines( VULKAN_HPP_NAMESPACE::Bool32 stippledSmoothLines_ ) VULKAN_HPP_NOEXCEPT
     {
       stippledSmoothLines = stippledSmoothLines_;
@@ -71026,14 +70867,14 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPhysicalDeviceLineRasterizationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceLineRasterizationFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT *>( this );
+      return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceLineRasterizationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceLineRasterizationFeaturesKHR &() VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT *>( this );
+      return *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesKHR *>( this );
     }
 
 #if defined( VULKAN_HPP_USE_REFLECT )
@@ -71056,9 +70897,9 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
-    auto operator<=>( PhysicalDeviceLineRasterizationFeaturesEXT const & ) const = default;
+    auto operator<=>( PhysicalDeviceLineRasterizationFeaturesKHR const & ) const = default;
 #else
-    bool operator==( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator==( PhysicalDeviceLineRasterizationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
 #  if defined( VULKAN_HPP_USE_REFLECT )
       return this->reflect() == rhs.reflect();
@@ -71069,14 +70910,14 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif
     }
 
-    bool operator!=( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator!=( PhysicalDeviceLineRasterizationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
       return !operator==( rhs );
     }
 #endif
 
   public:
-    VULKAN_HPP_NAMESPACE::StructureType sType                    = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT;
+    VULKAN_HPP_NAMESPACE::StructureType sType                    = StructureType::ePhysicalDeviceLineRasterizationFeaturesKHR;
     void *                              pNext                    = {};
     VULKAN_HPP_NAMESPACE::Bool32        rectangularLines         = {};
     VULKAN_HPP_NAMESPACE::Bool32        bresenhamLines           = {};
@@ -71087,49 +70928,51 @@ namespace VULKAN_HPP_NAMESPACE
   };
 
   template <>
-  struct CppType<StructureType, StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceLineRasterizationFeaturesKHR>
   {
-    using Type = PhysicalDeviceLineRasterizationFeaturesEXT;
+    using Type = PhysicalDeviceLineRasterizationFeaturesKHR;
   };
 
-  struct PhysicalDeviceLineRasterizationPropertiesEXT
+  using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeaturesKHR;
+
+  struct PhysicalDeviceLineRasterizationPropertiesKHR
   {
-    using NativeType = VkPhysicalDeviceLineRasterizationPropertiesEXT;
+    using NativeType = VkPhysicalDeviceLineRasterizationPropertiesKHR;
 
     static const bool                                  allowDuplicate = false;
-    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceLineRasterizationPropertiesKHR;
 
 #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-    VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationPropertiesEXT( uint32_t lineSubPixelPrecisionBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationPropertiesKHR( uint32_t lineSubPixelPrecisionBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
       : pNext( pNext_ )
       , lineSubPixelPrecisionBits( lineSubPixelPrecisionBits_ )
     {
     }
 
-    VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationPropertiesEXT( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationPropertiesKHR( PhysicalDeviceLineRasterizationPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 
-    PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : PhysicalDeviceLineRasterizationPropertiesEXT( *reinterpret_cast<PhysicalDeviceLineRasterizationPropertiesEXT const *>( &rhs ) )
+    PhysicalDeviceLineRasterizationPropertiesKHR( VkPhysicalDeviceLineRasterizationPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceLineRasterizationPropertiesKHR( *reinterpret_cast<PhysicalDeviceLineRasterizationPropertiesKHR const *>( &rhs ) )
     {
     }
 
-    PhysicalDeviceLineRasterizationPropertiesEXT & operator=( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+    PhysicalDeviceLineRasterizationPropertiesKHR & operator=( PhysicalDeviceLineRasterizationPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
 
-    PhysicalDeviceLineRasterizationPropertiesEXT & operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    PhysicalDeviceLineRasterizationPropertiesKHR & operator=( VkPhysicalDeviceLineRasterizationPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const *>( &rhs );
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR const *>( &rhs );
       return *this;
     }
 
-    operator VkPhysicalDeviceLineRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceLineRasterizationPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT *>( this );
+      return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesKHR *>( this );
     }
 
-    operator VkPhysicalDeviceLineRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceLineRasterizationPropertiesKHR &() VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT *>( this );
+      return *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesKHR *>( this );
     }
 
 #if defined( VULKAN_HPP_USE_REFLECT )
@@ -71145,9 +70988,9 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
-    auto operator<=>( PhysicalDeviceLineRasterizationPropertiesEXT const & ) const = default;
+    auto operator<=>( PhysicalDeviceLineRasterizationPropertiesKHR const & ) const = default;
 #else
-    bool operator==( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator==( PhysicalDeviceLineRasterizationPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
 #  if defined( VULKAN_HPP_USE_REFLECT )
       return this->reflect() == rhs.reflect();
@@ -71156,24 +70999,26 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif
     }
 
-    bool operator!=( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator!=( PhysicalDeviceLineRasterizationPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
       return !operator==( rhs );
     }
 #endif
 
   public:
-    VULKAN_HPP_NAMESPACE::StructureType sType                     = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT;
+    VULKAN_HPP_NAMESPACE::StructureType sType                     = StructureType::ePhysicalDeviceLineRasterizationPropertiesKHR;
     void *                              pNext                     = {};
     uint32_t                            lineSubPixelPrecisionBits = {};
   };
 
   template <>
-  struct CppType<StructureType, StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceLineRasterizationPropertiesKHR>
   {
-    using Type = PhysicalDeviceLineRasterizationPropertiesEXT;
+    using Type = PhysicalDeviceLineRasterizationPropertiesKHR;
   };
 
+  using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationPropertiesKHR;
+
   struct PhysicalDeviceLinearColorAttachmentFeaturesNV
   {
     using NativeType = VkPhysicalDeviceLinearColorAttachmentFeaturesNV;
@@ -82114,6 +81959,104 @@ namespace VULKAN_HPP_NAMESPACE
   };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
+  struct PhysicalDeviceShaderExpectAssumeFeaturesKHR
+  {
+    using NativeType = VkPhysicalDeviceShaderExpectAssumeFeaturesKHR;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceShaderExpectAssumeFeaturesKHR;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderExpectAssumeFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 shaderExpectAssume_ = {},
+                                                                      void *                       pNext_              = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , shaderExpectAssume( shaderExpectAssume_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderExpectAssumeFeaturesKHR( PhysicalDeviceShaderExpectAssumeFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceShaderExpectAssumeFeaturesKHR( VkPhysicalDeviceShaderExpectAssumeFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceShaderExpectAssumeFeaturesKHR( *reinterpret_cast<PhysicalDeviceShaderExpectAssumeFeaturesKHR const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceShaderExpectAssumeFeaturesKHR & operator=( PhysicalDeviceShaderExpectAssumeFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceShaderExpectAssumeFeaturesKHR & operator=( VkPhysicalDeviceShaderExpectAssumeFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderExpectAssumeFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderExpectAssumeFeaturesKHR &
+      setShaderExpectAssume( VULKAN_HPP_NAMESPACE::Bool32 shaderExpectAssume_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderExpectAssume = shaderExpectAssume_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkPhysicalDeviceShaderExpectAssumeFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *>( this );
+    }
+
+    operator VkPhysicalDeviceShaderExpectAssumeFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderExpectAssume );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceShaderExpectAssumeFeaturesKHR const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceShaderExpectAssumeFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderExpectAssume == rhs.shaderExpectAssume );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceShaderExpectAssumeFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType              = StructureType::ePhysicalDeviceShaderExpectAssumeFeaturesKHR;
+    void *                              pNext              = {};
+    VULKAN_HPP_NAMESPACE::Bool32        shaderExpectAssume = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderExpectAssumeFeaturesKHR>
+  {
+    using Type = PhysicalDeviceShaderExpectAssumeFeaturesKHR;
+  };
+
   struct PhysicalDeviceShaderFloat16Int8Features
   {
     using NativeType = VkPhysicalDeviceShaderFloat16Int8Features;
@@ -82223,6 +82166,105 @@ namespace VULKAN_HPP_NAMESPACE
   using PhysicalDeviceFloat16Int8FeaturesKHR       = PhysicalDeviceShaderFloat16Int8Features;
   using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
 
+  struct PhysicalDeviceShaderFloatControls2FeaturesKHR
+  {
+    using NativeType = VkPhysicalDeviceShaderFloatControls2FeaturesKHR;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceShaderFloatControls2FeaturesKHR;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloatControls2FeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 shaderFloatControls2_ = {},
+                                                                        void *                       pNext_                = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , shaderFloatControls2( shaderFloatControls2_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR
+      PhysicalDeviceShaderFloatControls2FeaturesKHR( PhysicalDeviceShaderFloatControls2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceShaderFloatControls2FeaturesKHR( VkPhysicalDeviceShaderFloatControls2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceShaderFloatControls2FeaturesKHR( *reinterpret_cast<PhysicalDeviceShaderFloatControls2FeaturesKHR const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceShaderFloatControls2FeaturesKHR & operator=( PhysicalDeviceShaderFloatControls2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceShaderFloatControls2FeaturesKHR & operator=( VkPhysicalDeviceShaderFloatControls2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloatControls2FeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloatControls2FeaturesKHR &
+      setShaderFloatControls2( VULKAN_HPP_NAMESPACE::Bool32 shaderFloatControls2_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderFloatControls2 = shaderFloatControls2_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkPhysicalDeviceShaderFloatControls2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2FeaturesKHR *>( this );
+    }
+
+    operator VkPhysicalDeviceShaderFloatControls2FeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderFloatControls2FeaturesKHR *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderFloatControls2 );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceShaderFloatControls2FeaturesKHR const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceShaderFloatControls2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloatControls2 == rhs.shaderFloatControls2 );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceShaderFloatControls2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType                = StructureType::ePhysicalDeviceShaderFloatControls2FeaturesKHR;
+    void *                              pNext                = {};
+    VULKAN_HPP_NAMESPACE::Bool32        shaderFloatControls2 = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderFloatControls2FeaturesKHR>
+  {
+    using Type = PhysicalDeviceShaderFloatControls2FeaturesKHR;
+  };
+
   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
@@ -82904,6 +82946,106 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
   };
 
+  struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR
+  {
+    using NativeType = VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 shaderMaximalReconvergence_ = {},
+                                                                              void *                       pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , shaderMaximalReconvergence( shaderMaximalReconvergence_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR
+      PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( *reinterpret_cast<PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR &
+      operator=( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR & operator=( VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR &
+      setShaderMaximalReconvergence( VULKAN_HPP_NAMESPACE::Bool32 shaderMaximalReconvergence_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderMaximalReconvergence = shaderMaximalReconvergence_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>( this );
+    }
+
+    operator VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderMaximalReconvergence );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderMaximalReconvergence == rhs.shaderMaximalReconvergence );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType                      = StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
+    void *                              pNext                      = {};
+    VULKAN_HPP_NAMESPACE::Bool32        shaderMaximalReconvergence = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>
+  {
+    using Type = PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
+  };
+
   struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT;
@@ -83273,6 +83415,104 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderObjectPropertiesEXT;
   };
 
+  struct PhysicalDeviceShaderQuadControlFeaturesKHR
+  {
+    using NativeType = VkPhysicalDeviceShaderQuadControlFeaturesKHR;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderQuadControlFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 shaderQuadControl_ = {},
+                                                                     void *                       pNext_             = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , shaderQuadControl( shaderQuadControl_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderQuadControlFeaturesKHR( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceShaderQuadControlFeaturesKHR( VkPhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceShaderQuadControlFeaturesKHR( *reinterpret_cast<PhysicalDeviceShaderQuadControlFeaturesKHR const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceShaderQuadControlFeaturesKHR & operator=( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceShaderQuadControlFeaturesKHR & operator=( VkPhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderQuadControlFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderQuadControlFeaturesKHR &
+      setShaderQuadControl( VULKAN_HPP_NAMESPACE::Bool32 shaderQuadControl_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderQuadControl = shaderQuadControl_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkPhysicalDeviceShaderQuadControlFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR *>( this );
+    }
+
+    operator VkPhysicalDeviceShaderQuadControlFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderQuadControlFeaturesKHR *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderQuadControl );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceShaderQuadControlFeaturesKHR const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderQuadControl == rhs.shaderQuadControl );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType             = StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR;
+    void *                              pNext             = {};
+    VULKAN_HPP_NAMESPACE::Bool32        shaderQuadControl = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR>
+  {
+    using Type = PhysicalDeviceShaderQuadControlFeaturesKHR;
+  };
+
   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV
   {
     using NativeType = VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;
@@ -83557,6 +83797,116 @@ namespace VULKAN_HPP_NAMESPACE
 
   using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
 
+  struct PhysicalDeviceShaderSubgroupRotateFeaturesKHR
+  {
+    using NativeType = VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceShaderSubgroupRotateFeaturesKHR;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupRotateFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupRotate_          = {},
+                                                                        VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupRotateClustered_ = {},
+                                                                        void *                       pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , shaderSubgroupRotate( shaderSubgroupRotate_ )
+      , shaderSubgroupRotateClustered( shaderSubgroupRotateClustered_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR
+      PhysicalDeviceShaderSubgroupRotateFeaturesKHR( PhysicalDeviceShaderSubgroupRotateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceShaderSubgroupRotateFeaturesKHR( VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceShaderSubgroupRotateFeaturesKHR( *reinterpret_cast<PhysicalDeviceShaderSubgroupRotateFeaturesKHR const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceShaderSubgroupRotateFeaturesKHR & operator=( PhysicalDeviceShaderSubgroupRotateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceShaderSubgroupRotateFeaturesKHR & operator=( VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeaturesKHR &
+      setShaderSubgroupRotate( VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupRotate_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderSubgroupRotate = shaderSubgroupRotate_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeaturesKHR &
+      setShaderSubgroupRotateClustered( VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupRotateClustered_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderSubgroupRotateClustered = shaderSubgroupRotateClustered_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *>( this );
+    }
+
+    operator VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderSubgroupRotate, shaderSubgroupRotateClustered );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceShaderSubgroupRotateFeaturesKHR const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceShaderSubgroupRotateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupRotate == rhs.shaderSubgroupRotate ) &&
+             ( shaderSubgroupRotateClustered == rhs.shaderSubgroupRotateClustered );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceShaderSubgroupRotateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType                         = StructureType::ePhysicalDeviceShaderSubgroupRotateFeaturesKHR;
+    void *                              pNext                         = {};
+    VULKAN_HPP_NAMESPACE::Bool32        shaderSubgroupRotate          = {};
+    VULKAN_HPP_NAMESPACE::Bool32        shaderSubgroupRotateClustered = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderSubgroupRotateFeaturesKHR>
+  {
+    using Type = PhysicalDeviceShaderSubgroupRotateFeaturesKHR;
+  };
+
   struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
@@ -92628,20 +92978,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 PipelinePropertiesIdentifierEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 PipelinePropertiesIdentifierEXT & setPipelineIdentifier( std::array<uint8_t, VK_UUID_SIZE> pipelineIdentifier_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pipelineIdentifier = pipelineIdentifier_;
-      return *this;
-    }
-#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
     operator VkPipelinePropertiesIdentifierEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelinePropertiesIdentifierEXT *>( this );
@@ -92933,16 +93269,16 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationDepthClipStateCreateInfoEXT;
   };
 
-  struct PipelineRasterizationLineStateCreateInfoEXT
+  struct PipelineRasterizationLineStateCreateInfoKHR
   {
-    using NativeType = VkPipelineRasterizationLineStateCreateInfoEXT;
+    using NativeType = VkPipelineRasterizationLineStateCreateInfoKHR;
 
     static const bool                                  allowDuplicate = false;
-    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePipelineRasterizationLineStateCreateInfoEXT;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePipelineRasterizationLineStateCreateInfoKHR;
 
 #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-    VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT(
-      VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode_ = VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT::eDefault,
+    VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoKHR(
+      VULKAN_HPP_NAMESPACE::LineRasterizationModeKHR lineRasterizationMode_ = VULKAN_HPP_NAMESPACE::LineRasterizationModeKHR::eDefault,
       VULKAN_HPP_NAMESPACE::Bool32                   stippledLineEnable_    = {},
       uint32_t                                       lineStippleFactor_     = {},
       uint16_t                                       lineStipplePattern_    = {},
@@ -92955,64 +93291,64 @@ namespace VULKAN_HPP_NAMESPACE
     {
     }
 
-    VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+    VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoKHR( PipelineRasterizationLineStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 
-    PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : PipelineRasterizationLineStateCreateInfoEXT( *reinterpret_cast<PipelineRasterizationLineStateCreateInfoEXT const *>( &rhs ) )
+    PipelineRasterizationLineStateCreateInfoKHR( VkPipelineRasterizationLineStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PipelineRasterizationLineStateCreateInfoKHR( *reinterpret_cast<PipelineRasterizationLineStateCreateInfoKHR const *>( &rhs ) )
     {
     }
 
-    PipelineRasterizationLineStateCreateInfoEXT & operator=( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+    PipelineRasterizationLineStateCreateInfoKHR & operator=( PipelineRasterizationLineStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
 
-    PipelineRasterizationLineStateCreateInfoEXT & operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    PipelineRasterizationLineStateCreateInfoKHR & operator=( VkPipelineRasterizationLineStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const *>( &rhs );
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR const *>( &rhs );
       return *this;
     }
 
 #if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfoEXT &
-      setLineRasterizationMode( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode_ ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfoKHR &
+      setLineRasterizationMode( VULKAN_HPP_NAMESPACE::LineRasterizationModeKHR lineRasterizationMode_ ) VULKAN_HPP_NOEXCEPT
     {
       lineRasterizationMode = lineRasterizationMode_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfoEXT &
+    VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfoKHR &
       setStippledLineEnable( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable_ ) VULKAN_HPP_NOEXCEPT
     {
       stippledLineEnable = stippledLineEnable_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfoEXT & setLineStippleFactor( uint32_t lineStippleFactor_ ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfoKHR & setLineStippleFactor( uint32_t lineStippleFactor_ ) VULKAN_HPP_NOEXCEPT
     {
       lineStippleFactor = lineStippleFactor_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfoEXT & setLineStipplePattern( uint16_t lineStipplePattern_ ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfoKHR & setLineStipplePattern( uint16_t lineStipplePattern_ ) VULKAN_HPP_NOEXCEPT
     {
       lineStipplePattern = lineStipplePattern_;
       return *this;
     }
 #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
 
-    operator VkPipelineRasterizationLineStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    operator VkPipelineRasterizationLineStateCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT *>( this );
+      return *reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoKHR *>( this );
     }
 
-    operator VkPipelineRasterizationLineStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    operator VkPipelineRasterizationLineStateCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT *>( this );
+      return *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoKHR *>( this );
     }
 
 #if defined( VULKAN_HPP_USE_REFLECT )
@@ -93021,7 +93357,7 @@ namespace VULKAN_HPP_NAMESPACE
 #  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
-               VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT const &,
+               VULKAN_HPP_NAMESPACE::LineRasterizationModeKHR const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint32_t const &,
                uint16_t const &>
@@ -93033,9 +93369,9 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
-    auto operator<=>( PipelineRasterizationLineStateCreateInfoEXT const & ) const = default;
+    auto operator<=>( PipelineRasterizationLineStateCreateInfoKHR const & ) const = default;
 #else
-    bool operator==( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator==( PipelineRasterizationLineStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
 #  if defined( VULKAN_HPP_USE_REFLECT )
       return this->reflect() == rhs.reflect();
@@ -93046,27 +93382,29 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif
     }
 
-    bool operator!=( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator!=( PipelineRasterizationLineStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
       return !operator==( rhs );
     }
 #endif
 
   public:
-    VULKAN_HPP_NAMESPACE::StructureType            sType                 = StructureType::ePipelineRasterizationLineStateCreateInfoEXT;
+    VULKAN_HPP_NAMESPACE::StructureType            sType                 = StructureType::ePipelineRasterizationLineStateCreateInfoKHR;
     const void *                                   pNext                 = {};
-    VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode = VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT::eDefault;
+    VULKAN_HPP_NAMESPACE::LineRasterizationModeKHR lineRasterizationMode = VULKAN_HPP_NAMESPACE::LineRasterizationModeKHR::eDefault;
     VULKAN_HPP_NAMESPACE::Bool32                   stippledLineEnable    = {};
     uint32_t                                       lineStippleFactor     = {};
     uint16_t                                       lineStipplePattern    = {};
   };
 
   template <>
-  struct CppType<StructureType, StructureType::ePipelineRasterizationLineStateCreateInfoEXT>
+  struct CppType<StructureType, StructureType::ePipelineRasterizationLineStateCreateInfoKHR>
   {
-    using Type = PipelineRasterizationLineStateCreateInfoEXT;
+    using Type = PipelineRasterizationLineStateCreateInfoKHR;
   };
 
+  using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfoKHR;
+
   struct PipelineRasterizationProvokingVertexStateCreateInfoEXT
   {
     using NativeType = VkPipelineRasterizationProvokingVertexStateCreateInfoEXT;
@@ -103456,6 +103794,133 @@ namespace VULKAN_HPP_NAMESPACE
 
   using RenderingAttachmentInfoKHR = RenderingAttachmentInfo;
 
+  struct RenderingAttachmentLocationInfoKHR
+  {
+    using NativeType = VkRenderingAttachmentLocationInfoKHR;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eRenderingAttachmentLocationInfoKHR;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR RenderingAttachmentLocationInfoKHR( uint32_t         colorAttachmentCount_      = {},
+                                                             const uint32_t * pColorAttachmentLocations_ = {},
+                                                             const void *     pNext_                     = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , colorAttachmentCount( colorAttachmentCount_ )
+      , pColorAttachmentLocations( pColorAttachmentLocations_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR RenderingAttachmentLocationInfoKHR( RenderingAttachmentLocationInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    RenderingAttachmentLocationInfoKHR( VkRenderingAttachmentLocationInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : RenderingAttachmentLocationInfoKHR( *reinterpret_cast<RenderingAttachmentLocationInfoKHR const *>( &rhs ) )
+    {
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    RenderingAttachmentLocationInfoKHR( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & colorAttachmentLocations_,
+                                        const void *                                                          pNext_ = nullptr )
+      : pNext( pNext_ )
+      , colorAttachmentCount( static_cast<uint32_t>( colorAttachmentLocations_.size() ) )
+      , pColorAttachmentLocations( colorAttachmentLocations_.data() )
+    {
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    RenderingAttachmentLocationInfoKHR & operator=( RenderingAttachmentLocationInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    RenderingAttachmentLocationInfoKHR & operator=( VkRenderingAttachmentLocationInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfoKHR & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      colorAttachmentCount = colorAttachmentCount_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfoKHR & setPColorAttachmentLocations( const uint32_t * pColorAttachmentLocations_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pColorAttachmentLocations = pColorAttachmentLocations_;
+      return *this;
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    RenderingAttachmentLocationInfoKHR &
+      setColorAttachmentLocations( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & colorAttachmentLocations_ ) VULKAN_HPP_NOEXCEPT
+    {
+      colorAttachmentCount      = static_cast<uint32_t>( colorAttachmentLocations_.size() );
+      pColorAttachmentLocations = colorAttachmentLocations_.data();
+      return *this;
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkRenderingAttachmentLocationInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkRenderingAttachmentLocationInfoKHR *>( this );
+    }
+
+    operator VkRenderingAttachmentLocationInfoKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkRenderingAttachmentLocationInfoKHR *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, const uint32_t * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentLocations );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( RenderingAttachmentLocationInfoKHR const & ) const = default;
+#else
+    bool operator==( RenderingAttachmentLocationInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
+             ( pColorAttachmentLocations == rhs.pColorAttachmentLocations );
+#  endif
+    }
+
+    bool operator!=( RenderingAttachmentLocationInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType                     = StructureType::eRenderingAttachmentLocationInfoKHR;
+    const void *                        pNext                     = {};
+    uint32_t                            colorAttachmentCount      = {};
+    const uint32_t *                    pColorAttachmentLocations = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::eRenderingAttachmentLocationInfoKHR>
+  {
+    using Type = RenderingAttachmentLocationInfoKHR;
+  };
+
   struct RenderingFragmentDensityMapAttachmentInfoEXT
   {
     using NativeType = VkRenderingFragmentDensityMapAttachmentInfoEXT;
@@ -103892,6 +104357,164 @@ namespace VULKAN_HPP_NAMESPACE
 
   using RenderingInfoKHR = RenderingInfo;
 
+  struct RenderingInputAttachmentIndexInfoKHR
+  {
+    using NativeType = VkRenderingInputAttachmentIndexInfoKHR;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eRenderingInputAttachmentIndexInfoKHR;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR RenderingInputAttachmentIndexInfoKHR( uint32_t         colorAttachmentCount_         = {},
+                                                               const uint32_t * pColorAttachmentInputIndices_ = {},
+                                                               const uint32_t * pDepthInputAttachmentIndex_   = {},
+                                                               const uint32_t * pStencilInputAttachmentIndex_ = {},
+                                                               const void *     pNext_                        = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , colorAttachmentCount( colorAttachmentCount_ )
+      , pColorAttachmentInputIndices( pColorAttachmentInputIndices_ )
+      , pDepthInputAttachmentIndex( pDepthInputAttachmentIndex_ )
+      , pStencilInputAttachmentIndex( pStencilInputAttachmentIndex_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR RenderingInputAttachmentIndexInfoKHR( RenderingInputAttachmentIndexInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    RenderingInputAttachmentIndexInfoKHR( VkRenderingInputAttachmentIndexInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+      : RenderingInputAttachmentIndexInfoKHR( *reinterpret_cast<RenderingInputAttachmentIndexInfoKHR const *>( &rhs ) )
+    {
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    RenderingInputAttachmentIndexInfoKHR( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & colorAttachmentInputIndices_,
+                                          const uint32_t *                                                      pDepthInputAttachmentIndex_   = {},
+                                          const uint32_t *                                                      pStencilInputAttachmentIndex_ = {},
+                                          const void *                                                          pNext_                        = nullptr )
+      : pNext( pNext_ )
+      , colorAttachmentCount( static_cast<uint32_t>( colorAttachmentInputIndices_.size() ) )
+      , pColorAttachmentInputIndices( colorAttachmentInputIndices_.data() )
+      , pDepthInputAttachmentIndex( pDepthInputAttachmentIndex_ )
+      , pStencilInputAttachmentIndex( pStencilInputAttachmentIndex_ )
+    {
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    RenderingInputAttachmentIndexInfoKHR & operator=( RenderingInputAttachmentIndexInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    RenderingInputAttachmentIndexInfoKHR & operator=( VkRenderingInputAttachmentIndexInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfoKHR & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      colorAttachmentCount = colorAttachmentCount_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfoKHR &
+      setPColorAttachmentInputIndices( const uint32_t * pColorAttachmentInputIndices_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pColorAttachmentInputIndices = pColorAttachmentInputIndices_;
+      return *this;
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    RenderingInputAttachmentIndexInfoKHR &
+      setColorAttachmentInputIndices( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const uint32_t> const & colorAttachmentInputIndices_ ) VULKAN_HPP_NOEXCEPT
+    {
+      colorAttachmentCount         = static_cast<uint32_t>( colorAttachmentInputIndices_.size() );
+      pColorAttachmentInputIndices = colorAttachmentInputIndices_.data();
+      return *this;
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfoKHR &
+      setPDepthInputAttachmentIndex( const uint32_t * pDepthInputAttachmentIndex_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pDepthInputAttachmentIndex = pDepthInputAttachmentIndex_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfoKHR &
+      setPStencilInputAttachmentIndex( const uint32_t * pStencilInputAttachmentIndex_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pStencilInputAttachmentIndex = pStencilInputAttachmentIndex_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkRenderingInputAttachmentIndexInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkRenderingInputAttachmentIndexInfoKHR *>( this );
+    }
+
+    operator VkRenderingInputAttachmentIndexInfoKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkRenderingInputAttachmentIndexInfoKHR *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const uint32_t * const &,
+               const uint32_t * const &,
+               const uint32_t * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentInputIndices, pDepthInputAttachmentIndex, pStencilInputAttachmentIndex );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( RenderingInputAttachmentIndexInfoKHR const & ) const = default;
+#else
+    bool operator==( RenderingInputAttachmentIndexInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
+             ( pColorAttachmentInputIndices == rhs.pColorAttachmentInputIndices ) && ( pDepthInputAttachmentIndex == rhs.pDepthInputAttachmentIndex ) &&
+             ( pStencilInputAttachmentIndex == rhs.pStencilInputAttachmentIndex );
+#  endif
+    }
+
+    bool operator!=( RenderingInputAttachmentIndexInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType                        = StructureType::eRenderingInputAttachmentIndexInfoKHR;
+    const void *                        pNext                        = {};
+    uint32_t                            colorAttachmentCount         = {};
+    const uint32_t *                    pColorAttachmentInputIndices = {};
+    const uint32_t *                    pDepthInputAttachmentIndex   = {};
+    const uint32_t *                    pStencilInputAttachmentIndex = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::eRenderingInputAttachmentIndexInfoKHR>
+  {
+    using Type = RenderingInputAttachmentIndexInfoKHR;
+  };
+
   struct ResolveImageInfo2
   {
     using NativeType = VkResolveImageInfo2;
diff --git a/include/vulkan/vulkan_to_string.hpp b/include/vulkan/vulkan_to_string.hpp
index e1ab55e..80aa4a5 100644
--- a/include/vulkan/vulkan_to_string.hpp
+++ b/include/vulkan/vulkan_to_string.hpp
@@ -4127,7 +4127,11 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceFragmentShadingRateKHR: return "PhysicalDeviceFragmentShadingRateKHR";
       case StructureType::ePhysicalDeviceShaderCoreProperties2AMD: return "PhysicalDeviceShaderCoreProperties2AMD";
       case StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD: return "PhysicalDeviceCoherentMemoryFeaturesAMD";
+      case StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeaturesKHR: return "PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR";
+      case StructureType::eRenderingAttachmentLocationInfoKHR: return "RenderingAttachmentLocationInfoKHR";
+      case StructureType::eRenderingInputAttachmentIndexInfoKHR: return "RenderingInputAttachmentIndexInfoKHR";
       case StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT: return "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT";
+      case StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR: return "PhysicalDeviceShaderQuadControlFeaturesKHR";
       case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT: return "PhysicalDeviceMemoryBudgetPropertiesEXT";
       case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT: return "PhysicalDeviceMemoryPriorityFeaturesEXT";
       case StructureType::eMemoryPriorityAllocateInfoEXT: return "MemoryPriorityAllocateInfoEXT";
@@ -4154,11 +4158,7 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT: return "SurfaceFullScreenExclusiveWin32InfoEXT";
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
       case StructureType::eHeadlessSurfaceCreateInfoEXT: return "HeadlessSurfaceCreateInfoEXT";
-      case StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT: return "PhysicalDeviceLineRasterizationFeaturesEXT";
-      case StructureType::ePipelineRasterizationLineStateCreateInfoEXT: return "PipelineRasterizationLineStateCreateInfoEXT";
-      case StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT: return "PhysicalDeviceLineRasterizationPropertiesEXT";
       case StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT: return "PhysicalDeviceShaderAtomicFloatFeaturesEXT";
-      case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT: return "PhysicalDeviceIndexTypeUint8FeaturesEXT";
       case StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT: return "PhysicalDeviceExtendedDynamicStateFeaturesEXT";
       case StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR: return "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR";
       case StructureType::ePipelineInfoKHR: return "PipelineInfoKHR";
@@ -4376,6 +4376,7 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT: return "SamplerBorderColorComponentMappingCreateInfoEXT";
       case StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT: return "PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT";
       case StructureType::ePhysicalDeviceShaderCorePropertiesARM: return "PhysicalDeviceShaderCorePropertiesARM";
+      case StructureType::ePhysicalDeviceShaderSubgroupRotateFeaturesKHR: return "PhysicalDeviceShaderSubgroupRotateFeaturesKHR";
       case StructureType::eDeviceQueueShaderCoreControlCreateInfoARM: return "DeviceQueueShaderCoreControlCreateInfoARM";
       case StructureType::ePhysicalDeviceSchedulingControlsFeaturesARM: return "PhysicalDeviceSchedulingControlsFeaturesARM";
       case StructureType::ePhysicalDeviceSchedulingControlsPropertiesARM: return "PhysicalDeviceSchedulingControlsPropertiesARM";
@@ -4402,6 +4403,7 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eComputePipelineIndirectBufferInfoNV: return "ComputePipelineIndirectBufferInfoNV";
       case StructureType::ePipelineIndirectDeviceAddressInfoNV: return "PipelineIndirectDeviceAddressInfoNV";
       case StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV: return "PhysicalDeviceLinearColorAttachmentFeaturesNV";
+      case StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR: return "PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR";
       case StructureType::ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT: return "PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT";
       case StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM: return "PhysicalDeviceImageProcessingFeaturesQCOM";
       case StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM: return "PhysicalDeviceImageProcessingPropertiesQCOM";
@@ -4494,6 +4496,7 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesKHR: return "PhysicalDeviceVertexAttributeDivisorPropertiesKHR";
       case StructureType::ePipelineVertexInputDivisorStateCreateInfoKHR: return "PipelineVertexInputDivisorStateCreateInfoKHR";
       case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesKHR: return "PhysicalDeviceVertexAttributeDivisorFeaturesKHR";
+      case StructureType::ePhysicalDeviceShaderFloatControls2FeaturesKHR: return "PhysicalDeviceShaderFloatControls2FeaturesKHR";
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
       case StructureType::eScreenBufferPropertiesQNX: return "ScreenBufferPropertiesQNX";
       case StructureType::eScreenBufferFormatPropertiesQNX: return "ScreenBufferFormatPropertiesQNX";
@@ -4502,7 +4505,12 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX";
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
       case StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT: return "PhysicalDeviceLayeredDriverPropertiesMSFT";
+      case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesKHR: return "PhysicalDeviceIndexTypeUint8FeaturesKHR";
+      case StructureType::ePhysicalDeviceLineRasterizationFeaturesKHR: return "PhysicalDeviceLineRasterizationFeaturesKHR";
+      case StructureType::ePipelineRasterizationLineStateCreateInfoKHR: return "PipelineRasterizationLineStateCreateInfoKHR";
+      case StructureType::ePhysicalDeviceLineRasterizationPropertiesKHR: return "PhysicalDeviceLineRasterizationPropertiesKHR";
       case StructureType::eCalibratedTimestampInfoKHR: return "CalibratedTimestampInfoKHR";
+      case StructureType::ePhysicalDeviceShaderExpectAssumeFeaturesKHR: return "PhysicalDeviceShaderExpectAssumeFeaturesKHR";
       case StructureType::ePhysicalDeviceMaintenance6FeaturesKHR: return "PhysicalDeviceMaintenance6FeaturesKHR";
       case StructureType::ePhysicalDeviceMaintenance6PropertiesKHR: return "PhysicalDeviceMaintenance6PropertiesKHR";
       case StructureType::eBindMemoryStatusKHR: return "BindMemoryStatusKHR";
@@ -5359,6 +5367,7 @@ namespace VULKAN_HPP_NAMESPACE
       case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR";
       case ImageLayout::eFragmentDensityMapOptimalEXT: return "FragmentDensityMapOptimalEXT";
       case ImageLayout::eFragmentShadingRateAttachmentOptimalKHR: return "FragmentShadingRateAttachmentOptimalKHR";
+      case ImageLayout::eRenderingLocalReadKHR: return "RenderingLocalReadKHR";
       case ImageLayout::eVideoEncodeDstKHR: return "VideoEncodeDstKHR";
       case ImageLayout::eVideoEncodeSrcKHR: return "VideoEncodeSrcKHR";
       case ImageLayout::eVideoEncodeDpbKHR: return "VideoEncodeDpbKHR";
@@ -5587,12 +5596,10 @@ namespace VULKAN_HPP_NAMESPACE
       case DynamicState::eExclusiveScissorEnableNV: return "ExclusiveScissorEnableNV";
       case DynamicState::eExclusiveScissorNV: return "ExclusiveScissorNV";
       case DynamicState::eFragmentShadingRateKHR: return "FragmentShadingRateKHR";
-      case DynamicState::eLineStippleEXT: return "LineStippleEXT";
       case DynamicState::eVertexInputEXT: return "VertexInputEXT";
       case DynamicState::ePatchControlPointsEXT: return "PatchControlPointsEXT";
       case DynamicState::eLogicOpEXT: return "LogicOpEXT";
       case DynamicState::eColorWriteEnableEXT: return "ColorWriteEnableEXT";
-      case DynamicState::eTessellationDomainOriginEXT: return "TessellationDomainOriginEXT";
       case DynamicState::eDepthClampEnableEXT: return "DepthClampEnableEXT";
       case DynamicState::ePolygonModeEXT: return "PolygonModeEXT";
       case DynamicState::eRasterizationSamplesEXT: return "RasterizationSamplesEXT";
@@ -5603,6 +5610,7 @@ namespace VULKAN_HPP_NAMESPACE
       case DynamicState::eColorBlendEnableEXT: return "ColorBlendEnableEXT";
       case DynamicState::eColorBlendEquationEXT: return "ColorBlendEquationEXT";
       case DynamicState::eColorWriteMaskEXT: return "ColorWriteMaskEXT";
+      case DynamicState::eTessellationDomainOriginEXT: return "TessellationDomainOriginEXT";
       case DynamicState::eRasterizationStreamEXT: return "RasterizationStreamEXT";
       case DynamicState::eConservativeRasterizationModeEXT: return "ConservativeRasterizationModeEXT";
       case DynamicState::eExtraPrimitiveOverestimationSizeEXT: return "ExtraPrimitiveOverestimationSizeEXT";
@@ -5624,6 +5632,7 @@ namespace VULKAN_HPP_NAMESPACE
       case DynamicState::eRepresentativeFragmentTestEnableNV: return "RepresentativeFragmentTestEnableNV";
       case DynamicState::eCoverageReductionModeNV: return "CoverageReductionModeNV";
       case DynamicState::eAttachmentFeedbackLoopEnableEXT: return "AttachmentFeedbackLoopEnableEXT";
+      case DynamicState::eLineStippleKHR: return "LineStippleKHR";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -6033,7 +6042,7 @@ namespace VULKAN_HPP_NAMESPACE
       case AttachmentLoadOp::eLoad: return "Load";
       case AttachmentLoadOp::eClear: return "Clear";
       case AttachmentLoadOp::eDontCare: return "DontCare";
-      case AttachmentLoadOp::eNoneEXT: return "NoneEXT";
+      case AttachmentLoadOp::eNoneKHR: return "NoneKHR";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -6176,7 +6185,7 @@ namespace VULKAN_HPP_NAMESPACE
       case IndexType::eUint16: return "Uint16";
       case IndexType::eUint32: return "Uint32";
       case IndexType::eNoneKHR: return "NoneKHR";
-      case IndexType::eUint8EXT: return "Uint8EXT";
+      case IndexType::eUint8KHR: return "Uint8KHR";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -8061,20 +8070,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "(void)";
   }
 
-  //=== VK_EXT_line_rasterization ===
-
-  VULKAN_HPP_INLINE std::string to_string( LineRasterizationModeEXT value )
-  {
-    switch ( value )
-    {
-      case LineRasterizationModeEXT::eDefault: return "Default";
-      case LineRasterizationModeEXT::eRectangular: return "Rectangular";
-      case LineRasterizationModeEXT::eBresenham: return "Bresenham";
-      case LineRasterizationModeEXT::eRectangularSmooth: return "RectangularSmooth";
-      default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
-    }
-  }
-
   //=== VK_KHR_pipeline_executable_properties ===
 
   VULKAN_HPP_INLINE std::string to_string( PipelineExecutableStatisticFormatKHR value )
@@ -9008,6 +9003,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  //=== VK_KHR_line_rasterization ===
+
+  VULKAN_HPP_INLINE std::string to_string( LineRasterizationModeKHR value )
+  {
+    switch ( value )
+    {
+      case LineRasterizationModeKHR::eDefault: return "Default";
+      case LineRasterizationModeKHR::eRectangular: return "Rectangular";
+      case LineRasterizationModeKHR::eBresenham: return "Bresenham";
+      case LineRasterizationModeKHR::eRectangularSmooth: return "RectangularSmooth";
+      default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
+    }
+  }
+
   //=== VK_KHR_calibrated_timestamps ===
 
   VULKAN_HPP_INLINE std::string to_string( TimeDomainKHR value )
diff --git a/registry/profiles/VP_KHR_roadmap_2022.json b/registry/profiles/VP_KHR_roadmap.json
index d950e77..e7a8500 100644
--- a/registry/profiles/VP_KHR_roadmap_2022.json
+++ b/registry/profiles/VP_KHR_roadmap.json
@@ -1,5 +1,5 @@
 {
-    "$schema": "https://schema.khronos.org/vulkan/profiles-0.8.1-204.json#",
+    "$schema": "https://schema.khronos.org/vulkan/profiles-0.8.2-276.json#",
     "capabilities": {
         "vulkan10requirements": {
             "features": {
@@ -8,6 +8,71 @@
                 }
             }
         },
+        "vulkan11requirements": {
+            "features": {
+                "VkPhysicalDeviceVulkan11Features": {
+                    "multiview": true
+                }
+            },
+            "properties": {
+                "VkPhysicalDeviceVulkan11Properties": {
+                    "maxMultiviewViewCount": 6,
+                    "maxMultiviewInstanceIndex": 134217727
+                }
+            }
+        },
+        "vulkan12requirements": {
+            "features": {
+                "VkPhysicalDeviceVulkan12Features": {
+                    "uniformBufferStandardLayout": true,
+                    "subgroupBroadcastDynamicId": true,
+                    "imagelessFramebuffer": true,
+                    "separateDepthStencilLayouts": true,
+                    "hostQueryReset": true,
+                    "timelineSemaphore": true,
+                    "shaderSubgroupExtendedTypes": true
+                }
+            },
+            "properties": {
+                "VkPhysicalDeviceVulkan12Properties": {
+                    "maxTimelineSemaphoreValueDifference": 2147483647
+                }
+            }
+        },
+        "vulkan13requirements": {
+            "features": {
+                "VkPhysicalDeviceVulkan12Features": {
+                    "vulkanMemoryModel": true,
+                    "vulkanMemoryModelDeviceScope": true,
+                    "bufferDeviceAddress": true
+                },
+                "VkPhysicalDeviceVulkan13Features": {
+                    "robustImageAccess": true,
+                    "shaderTerminateInvocation": true,
+                    "shaderZeroInitializeWorkgroupMemory": true,
+                    "synchronization2": true,
+                    "shaderIntegerDotProduct": true,
+                    "maintenance4": true,
+                    "pipelineCreationCacheControl": true,
+                    "subgroupSizeControl": true,
+                    "computeFullSubgroups": true,
+                    "shaderDemoteToHelperInvocation": true,
+                    "inlineUniformBlock": true,
+                    "dynamicRendering": true
+                }
+            },
+            "properties": {
+                "VkPhysicalDeviceVulkan13Properties": {
+                    "maxBufferSize": 1073741824,
+                    "maxInlineUniformBlockSize": 256,
+                    "maxPerStageDescriptorInlineUniformBlocks": 4,
+                    "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks": 4,
+                    "maxDescriptorSetInlineUniformBlocks": 4,
+                    "maxDescriptorSetUpdateAfterBindInlineUniformBlocks": 4,
+                    "maxInlineUniformTotalSize": 256
+                }
+            }
+        },
         "vulkan10requirements_roadmap2022": {
             "features": {
                 "VkPhysicalDeviceFeatures": {
@@ -76,19 +141,6 @@
                 }
             }
         },
-        "vulkan11requirements": {
-            "features": {
-                "VkPhysicalDeviceVulkan11Features": {
-                    "multiview": true
-                }
-            },
-            "properties": {
-                "VkPhysicalDeviceVulkan11Properties": {
-                    "maxMultiviewViewCount": 6,
-                    "maxMultiviewInstanceIndex": 134217727
-                }
-            }
-        },
         "vulkan11requirements_roadmap2022": {
             "features": {
                 "VkPhysicalDeviceVulkan11Features": {
@@ -103,24 +155,6 @@
                 }
             }
         },
-        "vulkan12requirements": {
-            "features": {
-                "VkPhysicalDeviceVulkan12Features": {
-                    "uniformBufferStandardLayout": true,
-                    "subgroupBroadcastDynamicId": true,
-                    "imagelessFramebuffer": true,
-                    "separateDepthStencilLayouts": true,
-                    "hostQueryReset": true,
-                    "timelineSemaphore": true,
-                    "shaderSubgroupExtendedTypes": true
-                }
-            },
-            "properties": {
-                "VkPhysicalDeviceVulkan12Properties": {
-                    "maxTimelineSemaphoreValueDifference": 2147483647
-                }
-            }
-        },
         "vulkan12requirements_roadmap2022": {
             "features": {
                 "VkPhysicalDeviceVulkan12Features": {
@@ -168,52 +202,103 @@
                 }
             }
         },
-        "vulkan13requirements": {
+        "vulkan13requirements_roadmap2022": {
+            "extensions": {
+                "VK_KHR_global_priority": 1
+            },
             "features": {
-                "VkPhysicalDeviceVulkan12Features": {
-                    "vulkanMemoryModel": true,
-                    "vulkanMemoryModelDeviceScope": true,
-                    "bufferDeviceAddress": true
-                },
                 "VkPhysicalDeviceVulkan13Features": {
-                    "robustImageAccess": true,
-                    "shaderTerminateInvocation": true,
-                    "shaderZeroInitializeWorkgroupMemory": true,
-                    "synchronization2": true,
-                    "shaderIntegerDotProduct": true,
-                    "maintenance4": true,
-                    "pipelineCreationCacheControl": true,
-                    "subgroupSizeControl": true,
-                    "computeFullSubgroups": true,
-                    "shaderDemoteToHelperInvocation": true,
-                    "inlineUniformBlock": true,
-                    "dynamicRendering": true
+                    "descriptorBindingInlineUniformBlockUpdateAfterBind": true
+                }
+            }
+        },
+        "vulkan10requirements_roadmap2024": {
+            "features": {
+                "VkPhysicalDeviceFeatures": {
+                    "multiDrawIndirect": true,
+                    "shaderInt16": true,
+                    "shaderImageGatherExtended": true
                 }
             },
             "properties": {
-                "VkPhysicalDeviceVulkan13Properties": {
-                    "maxBufferSize": 1073741824,
-                    "maxInlineUniformBlockSize": 256,
-                    "maxPerStageDescriptorInlineUniformBlocks": 4,
-                    "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks": 4,
-                    "maxDescriptorSetInlineUniformBlocks": 4,
-                    "maxDescriptorSetUpdateAfterBindInlineUniformBlocks": 4,
-                    "maxInlineUniformTotalSize": 256
+                "VkPhysicalDeviceProperties": {
+                    "limits": {
+                        "timestampComputeAndGraphics": true,
+                        "maxColorAttachments": 8,
+                        "maxBoundDescriptorSets": 7
+                    }
                 }
             }
         },
-        "vulkan13requirements_roadmap2022": {
-            "extensions": {
-                "VK_KHR_global_priority": 1
+        "vulkan11requirements_roadmap2024": {
+            "features": {
+                "VkPhysicalDeviceVulkan11Features": {
+                    "shaderDrawParameters": true,
+                    "storageBuffer16BitAccess": true
+                }
+            }
+        },
+        "vulkan12requirements_roadmap2024": {
+            "features": {
+                "VkPhysicalDeviceVulkan12Features": {
+                    "shaderInt8": true,
+                    "shaderFloat16": true,
+                    "storageBuffer8BitAccess": true
+                }
             },
+            "properties": {
+                "VkPhysicalDeviceVulkan12Properties": {
+                    "shaderRoundingModeRTEFloat16": true,
+                    "shaderRoundingModeRTEFloat32": true
+                }
+            }
+        },
+        "vulkan13requirements_roadmap2024": {
             "features": {
                 "VkPhysicalDeviceVulkan13Features": {
-                    "descriptorBindingInlineUniformBlockUpdateAfterBind": true
                 }
+            },
+            "properties": {
+                "VkPhysicalDeviceVulkan13Properties": {
+                }
+            }
+        },
+        "vulkanextensionrequirements_roadmap2024": {
+            "extensions": {
+                "VK_KHR_dynamic_rendering_local_read": 1,
+                "VK_KHR_load_store_op_none": 1,
+                "VK_KHR_shader_quad_control": 1,
+                "VK_KHR_shader_maximal_reconvergence": 1,
+                "VK_KHR_shader_subgroup_uniform_control_flow": 1,
+                "VK_KHR_shader_subgroup_rotate": 1,
+                "VK_KHR_shader_float_controls2": 1,
+                "VK_KHR_shader_expect_assume": 1,
+                "VK_KHR_line_rasterization": 1,
+                "VK_KHR_vertex_attribute_divisor": 1,
+                "VK_KHR_index_type_uint8": 1,
+                "VK_KHR_map_memory2": 1,
+                "VK_KHR_maintenance5": 1,
+                "VK_KHR_push_descriptor": 1
             }
         }
     },
     "profiles": {
+        "VP_KHR_roadmap_2024": {
+            "version": 1,
+            "api-version": "1.3.276",
+            "label": "Khronos Vulkan Roadmap 2024 profile",
+            "description": "This roadmap profile is intended to be supported by newer devices shipping in 2024 across mainstream smartphone, tablet, laptops, console and desktop devices.",
+            "profiles": [
+                "VP_KHR_roadmap_2022"
+            ],
+            "capabilities": [
+                "vulkan10requirements_roadmap2024",
+                "vulkan11requirements_roadmap2024",
+                "vulkan12requirements_roadmap2024",
+                "vulkan13requirements_roadmap2024",
+                "vulkanextensionrequirements_roadmap2024"
+            ]
+        },
         "VP_KHR_roadmap_2022": {
             "version": 1,
             "api-version": "1.3.204",
@@ -232,6 +317,12 @@
                 }
             },
             "history": [
+	        {
+	            "revision": 9,
+	            "date": "2024-01-16",
+	            "author": "Tobias Hector",
+	            "comment": "Add Roadmap 2024 profile"
+	        },
                 {
                     "revision": 8,
                     "date": "2023-11-02",
diff --git a/registry/validusage.json b/registry/validusage.json
index 3a2f133..64f2c03 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.3.275",
-    "comment": "from git branch: github-main commit: 9b94c27d65dc7d11e50a7c00581b89f1983d34ff",
-    "date": "2024-01-05 12:53:49Z"
+    "api version": "1.3.276",
+    "comment": "from git branch: github-main commit: bf11e6d4ca4b71ae311bb925ae68d215fbe09a86",
+    "date": "2024-01-25 08:53:29Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -369,7 +369,7 @@
         },
         {
           "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext",
-          "text": "Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceAccelerationStructurePropertiesKHR\">VkPhysicalDeviceAccelerationStructurePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI\">VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixPropertiesKHR\">VkPhysicalDeviceCooperativeMatrixPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixPropertiesNV\">VkPhysicalDeviceCooperativeMatrixPropertiesNV</a>, <a href=\"#VkPhysicalDeviceCopyMemoryIndirectPropertiesNV\">VkPhysicalDeviceCopyMemoryIndirectPropertiesNV</a>, <a href=\"#VkPhysicalDeviceCudaKernelLaunchPropertiesNV\">VkPhysicalDeviceCudaKernelLaunchPropertiesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorPropertiesEXT\">VkPhysicalDeviceCustomBorderColorPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDepthStencilResolveProperties\">VkPhysicalDeviceDepthStencilResolveProperties</a>, <a href=\"#VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT\">VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorBufferPropertiesEXT\">VkPhysicalDeviceDescriptorBufferPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingProperties\">VkPhysicalDeviceDescriptorIndexingProperties</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV\">VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDisplacementMicromapPropertiesNV\">VkPhysicalDeviceDisplacementMicromapPropertiesNV</a>, <a href=\"#VkPhysicalDeviceDriverProperties\">VkPhysicalDeviceDriverProperties</a>, <a href=\"#VkPhysicalDeviceDrmPropertiesEXT\">VkPhysicalDeviceDrmPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicState3PropertiesEXT\">VkPhysicalDeviceExtendedDynamicState3PropertiesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV\">VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV</a>, <a href=\"#VkPhysicalDeviceExternalFormatResolvePropertiesANDROID\">VkPhysicalDeviceExternalFormatResolvePropertiesANDROID</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsProperties\">VkPhysicalDeviceFloatControlsProperties</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2PropertiesEXT\">VkPhysicalDeviceFragmentDensityMap2PropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM\">VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapPropertiesEXT\">VkPhysicalDeviceFragmentDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR\">VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV\">VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRatePropertiesKHR\">VkPhysicalDeviceFragmentShadingRatePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT\">VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceHostImageCopyPropertiesEXT\">VkPhysicalDeviceHostImageCopyPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceImageProcessing2PropertiesQCOM\">VkPhysicalDeviceImageProcessing2PropertiesQCOM</a>, <a href=\"#VkPhysicalDeviceImageProcessingPropertiesQCOM\">VkPhysicalDeviceImageProcessingPropertiesQCOM</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockProperties\">VkPhysicalDeviceInlineUniformBlockProperties</a>, <a href=\"#VkPhysicalDeviceLayeredDriverPropertiesMSFT\">VkPhysicalDeviceLayeredDriverPropertiesMSFT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationPropertiesEXT\">VkPhysicalDeviceLineRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMaintenance4Properties\">VkPhysicalDeviceMaintenance4Properties</a>, <a href=\"#VkPhysicalDeviceMaintenance5PropertiesKHR\">VkPhysicalDeviceMaintenance5PropertiesKHR</a>, <a href=\"#VkPhysicalDeviceMaintenance6PropertiesKHR\">VkPhysicalDeviceMaintenance6PropertiesKHR</a>, <a href=\"#VkPhysicalDeviceMemoryDecompressionPropertiesNV\">VkPhysicalDeviceMemoryDecompressionPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesEXT\">VkPhysicalDeviceMeshShaderPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesNV\">VkPhysicalDeviceMeshShaderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMultiDrawPropertiesEXT\">VkPhysicalDeviceMultiDrawPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDeviceNestedCommandBufferPropertiesEXT\">VkPhysicalDeviceNestedCommandBufferPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceOpacityMicromapPropertiesEXT\">VkPhysicalDeviceOpacityMicromapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceOpticalFlowPropertiesNV\">VkPhysicalDeviceOpticalFlowPropertiesNV</a>, <a href=\"#VkPhysicalDevicePCIBusInfoPropertiesEXT\">VkPhysicalDevicePCIBusInfoPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePerformanceQueryPropertiesKHR\">VkPhysicalDevicePerformanceQueryPropertiesKHR</a>, <a href=\"#VkPhysicalDevicePipelineRobustnessPropertiesEXT\">VkPhysicalDevicePipelineRobustnessPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetPropertiesKHR\">VkPhysicalDevicePortabilitySubsetPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDeviceProvokingVertexPropertiesEXT\">VkPhysicalDeviceProvokingVertexPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV\">VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelinePropertiesKHR\">VkPhysicalDeviceRayTracingPipelinePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceRenderPassStripedPropertiesARM\">VkPhysicalDeviceRenderPassStripedPropertiesARM</a>, <a href=\"#VkPhysicalDeviceRobustness2PropertiesEXT\">VkPhysicalDeviceRobustness2PropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxProperties\">VkPhysicalDeviceSamplerFilterMinmaxProperties</a>, <a href=\"#VkPhysicalDeviceSchedulingControlsPropertiesARM\">VkPhysicalDeviceSchedulingControlsPropertiesARM</a>, <a href=\"#VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM\">VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM</a>, <a href=\"#VkPhysicalDeviceShaderCoreProperties2AMD\">VkPhysicalDeviceShaderCoreProperties2AMD</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesARM\">VkPhysicalDeviceShaderCorePropertiesARM</a>, <a href=\"#VkPhysicalDeviceShaderEnqueuePropertiesAMDX\">VkPhysicalDeviceShaderEnqueuePropertiesAMDX</a>, <a href=\"#VkPhysicalDeviceShaderIntegerDotProductProperties\">VkPhysicalDeviceShaderIntegerDotProductProperties</a>, <a href=\"#VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT\">VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShaderObjectPropertiesEXT\">VkPhysicalDeviceShaderObjectPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsPropertiesNV\">VkPhysicalDeviceShaderSMBuiltinsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceShaderTileImagePropertiesEXT\">VkPhysicalDeviceShaderTileImagePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShadingRateImagePropertiesNV\">VkPhysicalDeviceShadingRateImagePropertiesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlProperties\">VkPhysicalDeviceSubgroupSizeControlProperties</a>, <a href=\"#VkPhysicalDeviceSubpassShadingPropertiesHUAWEI\">VkPhysicalDeviceSubpassShadingPropertiesHUAWEI</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentProperties\">VkPhysicalDeviceTexelBufferAlignmentProperties</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreProperties\">VkPhysicalDeviceTimelineSemaphoreProperties</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR\">VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceVulkan11Properties\">VkPhysicalDeviceVulkan11Properties</a>, <a href=\"#VkPhysicalDeviceVulkan12Properties\">VkPhysicalDeviceVulkan12Properties</a>, or <a href=\"#VkPhysicalDeviceVulkan13Properties\">VkPhysicalDeviceVulkan13Properties</a>",
+          "text": "Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceAccelerationStructurePropertiesKHR\">VkPhysicalDeviceAccelerationStructurePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI\">VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixPropertiesKHR\">VkPhysicalDeviceCooperativeMatrixPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixPropertiesNV\">VkPhysicalDeviceCooperativeMatrixPropertiesNV</a>, <a href=\"#VkPhysicalDeviceCopyMemoryIndirectPropertiesNV\">VkPhysicalDeviceCopyMemoryIndirectPropertiesNV</a>, <a href=\"#VkPhysicalDeviceCudaKernelLaunchPropertiesNV\">VkPhysicalDeviceCudaKernelLaunchPropertiesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorPropertiesEXT\">VkPhysicalDeviceCustomBorderColorPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDepthStencilResolveProperties\">VkPhysicalDeviceDepthStencilResolveProperties</a>, <a href=\"#VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT\">VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorBufferPropertiesEXT\">VkPhysicalDeviceDescriptorBufferPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingProperties\">VkPhysicalDeviceDescriptorIndexingProperties</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV\">VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDisplacementMicromapPropertiesNV\">VkPhysicalDeviceDisplacementMicromapPropertiesNV</a>, <a href=\"#VkPhysicalDeviceDriverProperties\">VkPhysicalDeviceDriverProperties</a>, <a href=\"#VkPhysicalDeviceDrmPropertiesEXT\">VkPhysicalDeviceDrmPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicState3PropertiesEXT\">VkPhysicalDeviceExtendedDynamicState3PropertiesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV\">VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV</a>, <a href=\"#VkPhysicalDeviceExternalFormatResolvePropertiesANDROID\">VkPhysicalDeviceExternalFormatResolvePropertiesANDROID</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsProperties\">VkPhysicalDeviceFloatControlsProperties</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2PropertiesEXT\">VkPhysicalDeviceFragmentDensityMap2PropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM\">VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapPropertiesEXT\">VkPhysicalDeviceFragmentDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR\">VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV\">VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRatePropertiesKHR\">VkPhysicalDeviceFragmentShadingRatePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT\">VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceHostImageCopyPropertiesEXT\">VkPhysicalDeviceHostImageCopyPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceImageProcessing2PropertiesQCOM\">VkPhysicalDeviceImageProcessing2PropertiesQCOM</a>, <a href=\"#VkPhysicalDeviceImageProcessingPropertiesQCOM\">VkPhysicalDeviceImageProcessingPropertiesQCOM</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockProperties\">VkPhysicalDeviceInlineUniformBlockProperties</a>, <a href=\"#VkPhysicalDeviceLayeredDriverPropertiesMSFT\">VkPhysicalDeviceLayeredDriverPropertiesMSFT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationPropertiesKHR\">VkPhysicalDeviceLineRasterizationPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMaintenance4Properties\">VkPhysicalDeviceMaintenance4Properties</a>, <a href=\"#VkPhysicalDeviceMaintenance5PropertiesKHR\">VkPhysicalDeviceMaintenance5PropertiesKHR</a>, <a href=\"#VkPhysicalDeviceMaintenance6PropertiesKHR\">VkPhysicalDeviceMaintenance6PropertiesKHR</a>, <a href=\"#VkPhysicalDeviceMemoryDecompressionPropertiesNV\">VkPhysicalDeviceMemoryDecompressionPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesEXT\">VkPhysicalDeviceMeshShaderPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesNV\">VkPhysicalDeviceMeshShaderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMultiDrawPropertiesEXT\">VkPhysicalDeviceMultiDrawPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDeviceNestedCommandBufferPropertiesEXT\">VkPhysicalDeviceNestedCommandBufferPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceOpacityMicromapPropertiesEXT\">VkPhysicalDeviceOpacityMicromapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceOpticalFlowPropertiesNV\">VkPhysicalDeviceOpticalFlowPropertiesNV</a>, <a href=\"#VkPhysicalDevicePCIBusInfoPropertiesEXT\">VkPhysicalDevicePCIBusInfoPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePerformanceQueryPropertiesKHR\">VkPhysicalDevicePerformanceQueryPropertiesKHR</a>, <a href=\"#VkPhysicalDevicePipelineRobustnessPropertiesEXT\">VkPhysicalDevicePipelineRobustnessPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetPropertiesKHR\">VkPhysicalDevicePortabilitySubsetPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDeviceProvokingVertexPropertiesEXT\">VkPhysicalDeviceProvokingVertexPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV\">VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelinePropertiesKHR\">VkPhysicalDeviceRayTracingPipelinePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceRenderPassStripedPropertiesARM\">VkPhysicalDeviceRenderPassStripedPropertiesARM</a>, <a href=\"#VkPhysicalDeviceRobustness2PropertiesEXT\">VkPhysicalDeviceRobustness2PropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxProperties\">VkPhysicalDeviceSamplerFilterMinmaxProperties</a>, <a href=\"#VkPhysicalDeviceSchedulingControlsPropertiesARM\">VkPhysicalDeviceSchedulingControlsPropertiesARM</a>, <a href=\"#VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM\">VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM</a>, <a href=\"#VkPhysicalDeviceShaderCoreProperties2AMD\">VkPhysicalDeviceShaderCoreProperties2AMD</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesARM\">VkPhysicalDeviceShaderCorePropertiesARM</a>, <a href=\"#VkPhysicalDeviceShaderEnqueuePropertiesAMDX\">VkPhysicalDeviceShaderEnqueuePropertiesAMDX</a>, <a href=\"#VkPhysicalDeviceShaderIntegerDotProductProperties\">VkPhysicalDeviceShaderIntegerDotProductProperties</a>, <a href=\"#VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT\">VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShaderObjectPropertiesEXT\">VkPhysicalDeviceShaderObjectPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsPropertiesNV\">VkPhysicalDeviceShaderSMBuiltinsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceShaderTileImagePropertiesEXT\">VkPhysicalDeviceShaderTileImagePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShadingRateImagePropertiesNV\">VkPhysicalDeviceShadingRateImagePropertiesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlProperties\">VkPhysicalDeviceSubgroupSizeControlProperties</a>, <a href=\"#VkPhysicalDeviceSubpassShadingPropertiesHUAWEI\">VkPhysicalDeviceSubpassShadingPropertiesHUAWEI</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentProperties\">VkPhysicalDeviceTexelBufferAlignmentProperties</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreProperties\">VkPhysicalDeviceTimelineSemaphoreProperties</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR\">VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceVulkan11Properties\">VkPhysicalDeviceVulkan11Properties</a>, <a href=\"#VkPhysicalDeviceVulkan12Properties\">VkPhysicalDeviceVulkan12Properties</a>, or <a href=\"#VkPhysicalDeviceVulkan13Properties\">VkPhysicalDeviceVulkan13Properties</a>",
           "page": "vkspec"
         },
         {
@@ -891,7 +891,7 @@
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext",
-          "text": "Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceDeviceMemoryReportCreateInfoEXT\">VkDeviceDeviceMemoryReportCreateInfoEXT</a>, <a href=\"#VkDeviceDiagnosticsConfigCreateInfoNV\">VkDeviceDiagnosticsConfigCreateInfoNV</a>, <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkDevicePrivateDataCreateInfo\">VkDevicePrivateDataCreateInfo</a>, <a href=\"#VkDeviceQueueShaderCoreControlCreateInfoARM\">VkDeviceQueueShaderCoreControlCreateInfoARM</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice4444FormatsFeaturesEXT\">VkPhysicalDevice4444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDevice8BitStorageFeatures\">VkPhysicalDevice8BitStorageFeatures</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAccelerationStructureFeaturesKHR\">VkPhysicalDeviceAccelerationStructureFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceAddressBindingReportFeaturesEXT\">VkPhysicalDeviceAddressBindingReportFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAmigoProfilingFeaturesSEC\">VkPhysicalDeviceAmigoProfilingFeaturesSEC</a>, <a href=\"#VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT\">VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT\">VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBorderColorSwizzleFeaturesEXT\">VkPhysicalDeviceBorderColorSwizzleFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeatures\">VkPhysicalDeviceBufferDeviceAddressFeatures</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\">VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI\">VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI</a>, <a href=\"#VkPhysicalDeviceCoherentMemoryFeaturesAMD\">VkPhysicalDeviceCoherentMemoryFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceColorWriteEnableFeaturesEXT\">VkPhysicalDeviceColorWriteEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesKHR\">VkPhysicalDeviceCooperativeMatrixFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesNV\">VkPhysicalDeviceCooperativeMatrixFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCopyMemoryIndirectFeaturesNV\">VkPhysicalDeviceCopyMemoryIndirectFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCoverageReductionModeFeaturesNV\">VkPhysicalDeviceCoverageReductionModeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCubicClampFeaturesQCOM\">VkPhysicalDeviceCubicClampFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceCubicWeightsFeaturesQCOM\">VkPhysicalDeviceCubicWeightsFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceCudaKernelLaunchFeaturesNV\">VkPhysicalDeviceCudaKernelLaunchFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorFeaturesEXT\">VkPhysicalDeviceCustomBorderColorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV\">VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDepthBiasControlFeaturesEXT\">VkPhysicalDeviceDepthBiasControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDepthClampZeroOneFeaturesEXT\">VkPhysicalDeviceDepthClampZeroOneFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDepthClipControlFeaturesEXT\">VkPhysicalDeviceDepthClipControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDepthClipEnableFeaturesEXT\">VkPhysicalDeviceDepthClipEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorBufferFeaturesEXT\">VkPhysicalDeviceDescriptorBufferFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeatures\">VkPhysicalDeviceDescriptorIndexingFeatures</a>, <a href=\"#VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV\">VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE\">VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDeviceMemoryReportFeaturesEXT\">VkPhysicalDeviceDeviceMemoryReportFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDiagnosticsConfigFeaturesNV\">VkPhysicalDeviceDiagnosticsConfigFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDisplacementMicromapFeaturesNV\">VkPhysicalDeviceDisplacementMicromapFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDynamicRenderingFeatures\">VkPhysicalDeviceDynamicRenderingFeatures</a>, <a href=\"#VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT\">VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicState2FeaturesEXT\">VkPhysicalDeviceExtendedDynamicState2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicState3FeaturesEXT\">VkPhysicalDeviceExtendedDynamicState3FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicStateFeaturesEXT\">VkPhysicalDeviceExtendedDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV\">VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExternalFormatResolveFeaturesANDROID\">VkPhysicalDeviceExternalFormatResolveFeaturesANDROID</a>, <a href=\"#VkPhysicalDeviceExternalMemoryRDMAFeaturesNV\">VkPhysicalDeviceExternalMemoryRDMAFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX\">VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX</a>, <a href=\"#VkPhysicalDeviceFaultFeaturesEXT\">VkPhysicalDeviceFaultFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2FeaturesEXT\">VkPhysicalDeviceFragmentDensityMap2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM\">VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\">VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV\">VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateFeaturesKHR\">VkPhysicalDeviceFragmentShadingRateFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceFrameBoundaryFeaturesEXT\">VkPhysicalDeviceFrameBoundaryFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR\">VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT\">VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceHostImageCopyFeaturesEXT\">VkPhysicalDeviceHostImageCopyFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceHostQueryResetFeatures\">VkPhysicalDeviceHostQueryResetFeatures</a>, <a href=\"#VkPhysicalDeviceImage2DViewOf3DFeaturesEXT\">VkPhysicalDeviceImage2DViewOf3DFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImageCompressionControlFeaturesEXT\">VkPhysicalDeviceImageCompressionControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT\">VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImageProcessing2FeaturesQCOM\">VkPhysicalDeviceImageProcessing2FeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceImageProcessingFeaturesQCOM\">VkPhysicalDeviceImageProcessingFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceImageRobustnessFeatures\">VkPhysicalDeviceImageRobustnessFeatures</a>, <a href=\"#VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT\">VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImageViewMinLodFeaturesEXT\">VkPhysicalDeviceImageViewMinLodFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeatures\">VkPhysicalDeviceImagelessFramebufferFeatures</a>, <a href=\"#VkPhysicalDeviceIndexTypeUint8FeaturesEXT\">VkPhysicalDeviceIndexTypeUint8FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceInheritedViewportScissorFeaturesNV\">VkPhysicalDeviceInheritedViewportScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeatures\">VkPhysicalDeviceInlineUniformBlockFeatures</a>, <a href=\"#VkPhysicalDeviceInvocationMaskFeaturesHUAWEI\">VkPhysicalDeviceInvocationMaskFeaturesHUAWEI</a>, <a href=\"#VkPhysicalDeviceLegacyDitheringFeaturesEXT\">VkPhysicalDeviceLegacyDitheringFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationFeaturesEXT\">VkPhysicalDeviceLineRasterizationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceLinearColorAttachmentFeaturesNV\">VkPhysicalDeviceLinearColorAttachmentFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMaintenance4Features\">VkPhysicalDeviceMaintenance4Features</a>, <a href=\"#VkPhysicalDeviceMaintenance5FeaturesKHR\">VkPhysicalDeviceMaintenance5FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceMaintenance6FeaturesKHR\">VkPhysicalDeviceMaintenance6FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceMemoryDecompressionFeaturesNV\">VkPhysicalDeviceMemoryDecompressionFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesEXT\">VkPhysicalDeviceMeshShaderFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiDrawFeaturesEXT\">VkPhysicalDeviceMultiDrawFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT\">VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM\">VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM\">VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT\">VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceNestedCommandBufferFeaturesEXT\">VkPhysicalDeviceNestedCommandBufferFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT\">VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceOpacityMicromapFeaturesEXT\">VkPhysicalDeviceOpacityMicromapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceOpticalFlowFeaturesNV\">VkPhysicalDeviceOpticalFlowFeaturesNV</a>, <a href=\"#VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT\">VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePerStageDescriptorSetFeaturesNV\">VkPhysicalDevicePerStageDescriptorSetFeaturesNV</a>, <a href=\"#VkPhysicalDevicePerformanceQueryFeaturesKHR\">VkPhysicalDevicePerformanceQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineCreationCacheControlFeatures\">VkPhysicalDevicePipelineCreationCacheControlFeatures</a>, <a href=\"#VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\">VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT\">VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelinePropertiesFeaturesEXT\">VkPhysicalDevicePipelinePropertiesFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineProtectedAccessFeaturesEXT\">VkPhysicalDevicePipelineProtectedAccessFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineRobustnessFeaturesEXT\">VkPhysicalDevicePipelineRobustnessFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetFeaturesKHR\">VkPhysicalDevicePortabilitySubsetFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePresentBarrierFeaturesNV\">VkPhysicalDevicePresentBarrierFeaturesNV</a>, <a href=\"#VkPhysicalDevicePresentIdFeaturesKHR\">VkPhysicalDevicePresentIdFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePresentWaitFeaturesKHR\">VkPhysicalDevicePresentWaitFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT\">VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT\">VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePrivateDataFeatures\">VkPhysicalDevicePrivateDataFeatures</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceProvokingVertexFeaturesEXT\">VkPhysicalDeviceProvokingVertexFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT\">VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT\">VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceRayQueryFeaturesKHR\">VkPhysicalDeviceRayQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV\">VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR\">VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingMotionBlurFeaturesNV\">VkPhysicalDeviceRayTracingMotionBlurFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelineFeaturesKHR\">VkPhysicalDeviceRayTracingPipelineFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR\">VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG\">VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG</a>, <a href=\"#VkPhysicalDeviceRenderPassStripedFeaturesARM\">VkPhysicalDeviceRenderPassStripedFeaturesARM</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2FeaturesEXT\">VkPhysicalDeviceRobustness2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeatures\">VkPhysicalDeviceScalarBlockLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceSchedulingControlsFeaturesARM\">VkPhysicalDeviceSchedulingControlsFeaturesARM</a>, <a href=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT\">VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloatFeaturesEXT\">VkPhysicalDeviceShaderAtomicFloatFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64Features\">VkPhysicalDeviceShaderAtomicInt64Features</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM\">VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD\">VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceShaderEnqueueFeaturesAMDX\">VkPhysicalDeviceShaderEnqueueFeaturesAMDX</a>, <a href=\"#VkPhysicalDeviceShaderFloat16Int8Features\">VkPhysicalDeviceShaderFloat16Int8Features</a>, <a href=\"#VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT\">VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerDotProductFeatures\">VkPhysicalDeviceShaderIntegerDotProductFeatures</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\">VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL</a>, <a href=\"#VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT\">VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderObjectFeaturesEXT\">VkPhysicalDeviceShaderObjectFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR\">VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderTerminateInvocationFeatures\">VkPhysicalDeviceShaderTerminateInvocationFeatures</a>, <a href=\"#VkPhysicalDeviceShaderTileImageFeaturesEXT\">VkPhysicalDeviceShaderTileImageFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeatures\">VkPhysicalDeviceSubgroupSizeControlFeatures</a>, <a href=\"#VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT\">VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSubpassShadingFeaturesHUAWEI\">VkPhysicalDeviceSubpassShadingFeaturesHUAWEI</a>, <a href=\"#VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT\">VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSynchronization2Features\">VkPhysicalDeviceSynchronization2Features</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeatures\">VkPhysicalDeviceTextureCompressionASTCHDRFeatures</a>, <a href=\"#VkPhysicalDeviceTilePropertiesFeaturesQCOM\">VkPhysicalDeviceTilePropertiesFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeatures\">VkPhysicalDeviceTimelineSemaphoreFeatures</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeatures\">VkPhysicalDeviceUniformBufferStandardLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR\">VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT\">VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVideoMaintenance1FeaturesKHR\">VkPhysicalDeviceVideoMaintenance1FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a>, <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>, <a href=\"#VkPhysicalDeviceVulkan13Features\">VkPhysicalDeviceVulkan13Features</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeatures\">VkPhysicalDeviceVulkanMemoryModelFeatures</a>, <a href=\"#VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR\">VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT\">VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceYcbcrDegammaFeaturesQCOM\">VkPhysicalDeviceYcbcrDegammaFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\">VkPhysicalDeviceYcbcrImageArraysFeaturesEXT</a>, or <a href=\"#VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures\">VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures</a>",
+          "text": "Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceDeviceMemoryReportCreateInfoEXT\">VkDeviceDeviceMemoryReportCreateInfoEXT</a>, <a href=\"#VkDeviceDiagnosticsConfigCreateInfoNV\">VkDeviceDiagnosticsConfigCreateInfoNV</a>, <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkDevicePrivateDataCreateInfo\">VkDevicePrivateDataCreateInfo</a>, <a href=\"#VkDeviceQueueShaderCoreControlCreateInfoARM\">VkDeviceQueueShaderCoreControlCreateInfoARM</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice4444FormatsFeaturesEXT\">VkPhysicalDevice4444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDevice8BitStorageFeatures\">VkPhysicalDevice8BitStorageFeatures</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAccelerationStructureFeaturesKHR\">VkPhysicalDeviceAccelerationStructureFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceAddressBindingReportFeaturesEXT\">VkPhysicalDeviceAddressBindingReportFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAmigoProfilingFeaturesSEC\">VkPhysicalDeviceAmigoProfilingFeaturesSEC</a>, <a href=\"#VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT\">VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT\">VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBorderColorSwizzleFeaturesEXT\">VkPhysicalDeviceBorderColorSwizzleFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeatures\">VkPhysicalDeviceBufferDeviceAddressFeatures</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\">VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI\">VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI</a>, <a href=\"#VkPhysicalDeviceCoherentMemoryFeaturesAMD\">VkPhysicalDeviceCoherentMemoryFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceColorWriteEnableFeaturesEXT\">VkPhysicalDeviceColorWriteEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesKHR\">VkPhysicalDeviceCooperativeMatrixFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesNV\">VkPhysicalDeviceCooperativeMatrixFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCopyMemoryIndirectFeaturesNV\">VkPhysicalDeviceCopyMemoryIndirectFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCoverageReductionModeFeaturesNV\">VkPhysicalDeviceCoverageReductionModeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCubicClampFeaturesQCOM\">VkPhysicalDeviceCubicClampFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceCubicWeightsFeaturesQCOM\">VkPhysicalDeviceCubicWeightsFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceCudaKernelLaunchFeaturesNV\">VkPhysicalDeviceCudaKernelLaunchFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorFeaturesEXT\">VkPhysicalDeviceCustomBorderColorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV\">VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDepthBiasControlFeaturesEXT\">VkPhysicalDeviceDepthBiasControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDepthClampZeroOneFeaturesEXT\">VkPhysicalDeviceDepthClampZeroOneFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDepthClipControlFeaturesEXT\">VkPhysicalDeviceDepthClipControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDepthClipEnableFeaturesEXT\">VkPhysicalDeviceDepthClipEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorBufferFeaturesEXT\">VkPhysicalDeviceDescriptorBufferFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeatures\">VkPhysicalDeviceDescriptorIndexingFeatures</a>, <a href=\"#VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV\">VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE\">VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDeviceMemoryReportFeaturesEXT\">VkPhysicalDeviceDeviceMemoryReportFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDiagnosticsConfigFeaturesNV\">VkPhysicalDeviceDiagnosticsConfigFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDisplacementMicromapFeaturesNV\">VkPhysicalDeviceDisplacementMicromapFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDynamicRenderingFeatures\">VkPhysicalDeviceDynamicRenderingFeatures</a>, <a href=\"#VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR\">VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT\">VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicState2FeaturesEXT\">VkPhysicalDeviceExtendedDynamicState2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicState3FeaturesEXT\">VkPhysicalDeviceExtendedDynamicState3FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicStateFeaturesEXT\">VkPhysicalDeviceExtendedDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV\">VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExternalFormatResolveFeaturesANDROID\">VkPhysicalDeviceExternalFormatResolveFeaturesANDROID</a>, <a href=\"#VkPhysicalDeviceExternalMemoryRDMAFeaturesNV\">VkPhysicalDeviceExternalMemoryRDMAFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX\">VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX</a>, <a href=\"#VkPhysicalDeviceFaultFeaturesEXT\">VkPhysicalDeviceFaultFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2FeaturesEXT\">VkPhysicalDeviceFragmentDensityMap2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM\">VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\">VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV\">VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateFeaturesKHR\">VkPhysicalDeviceFragmentShadingRateFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceFrameBoundaryFeaturesEXT\">VkPhysicalDeviceFrameBoundaryFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR\">VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT\">VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceHostImageCopyFeaturesEXT\">VkPhysicalDeviceHostImageCopyFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceHostQueryResetFeatures\">VkPhysicalDeviceHostQueryResetFeatures</a>, <a href=\"#VkPhysicalDeviceImage2DViewOf3DFeaturesEXT\">VkPhysicalDeviceImage2DViewOf3DFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImageCompressionControlFeaturesEXT\">VkPhysicalDeviceImageCompressionControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT\">VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImageProcessing2FeaturesQCOM\">VkPhysicalDeviceImageProcessing2FeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceImageProcessingFeaturesQCOM\">VkPhysicalDeviceImageProcessingFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceImageRobustnessFeatures\">VkPhysicalDeviceImageRobustnessFeatures</a>, <a href=\"#VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT\">VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImageViewMinLodFeaturesEXT\">VkPhysicalDeviceImageViewMinLodFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeatures\">VkPhysicalDeviceImagelessFramebufferFeatures</a>, <a href=\"#VkPhysicalDeviceIndexTypeUint8FeaturesKHR\">VkPhysicalDeviceIndexTypeUint8FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceInheritedViewportScissorFeaturesNV\">VkPhysicalDeviceInheritedViewportScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeatures\">VkPhysicalDeviceInlineUniformBlockFeatures</a>, <a href=\"#VkPhysicalDeviceInvocationMaskFeaturesHUAWEI\">VkPhysicalDeviceInvocationMaskFeaturesHUAWEI</a>, <a href=\"#VkPhysicalDeviceLegacyDitheringFeaturesEXT\">VkPhysicalDeviceLegacyDitheringFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationFeaturesKHR\">VkPhysicalDeviceLineRasterizationFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceLinearColorAttachmentFeaturesNV\">VkPhysicalDeviceLinearColorAttachmentFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMaintenance4Features\">VkPhysicalDeviceMaintenance4Features</a>, <a href=\"#VkPhysicalDeviceMaintenance5FeaturesKHR\">VkPhysicalDeviceMaintenance5FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceMaintenance6FeaturesKHR\">VkPhysicalDeviceMaintenance6FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceMemoryDecompressionFeaturesNV\">VkPhysicalDeviceMemoryDecompressionFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesEXT\">VkPhysicalDeviceMeshShaderFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiDrawFeaturesEXT\">VkPhysicalDeviceMultiDrawFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT\">VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM\">VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM\">VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT\">VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceNestedCommandBufferFeaturesEXT\">VkPhysicalDeviceNestedCommandBufferFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT\">VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceOpacityMicromapFeaturesEXT\">VkPhysicalDeviceOpacityMicromapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceOpticalFlowFeaturesNV\">VkPhysicalDeviceOpticalFlowFeaturesNV</a>, <a href=\"#VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT\">VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePerStageDescriptorSetFeaturesNV\">VkPhysicalDevicePerStageDescriptorSetFeaturesNV</a>, <a href=\"#VkPhysicalDevicePerformanceQueryFeaturesKHR\">VkPhysicalDevicePerformanceQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineCreationCacheControlFeatures\">VkPhysicalDevicePipelineCreationCacheControlFeatures</a>, <a href=\"#VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\">VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT\">VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelinePropertiesFeaturesEXT\">VkPhysicalDevicePipelinePropertiesFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineProtectedAccessFeaturesEXT\">VkPhysicalDevicePipelineProtectedAccessFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineRobustnessFeaturesEXT\">VkPhysicalDevicePipelineRobustnessFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetFeaturesKHR\">VkPhysicalDevicePortabilitySubsetFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePresentBarrierFeaturesNV\">VkPhysicalDevicePresentBarrierFeaturesNV</a>, <a href=\"#VkPhysicalDevicePresentIdFeaturesKHR\">VkPhysicalDevicePresentIdFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePresentWaitFeaturesKHR\">VkPhysicalDevicePresentWaitFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT\">VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT\">VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePrivateDataFeatures\">VkPhysicalDevicePrivateDataFeatures</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceProvokingVertexFeaturesEXT\">VkPhysicalDeviceProvokingVertexFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT\">VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT\">VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceRayQueryFeaturesKHR\">VkPhysicalDeviceRayQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV\">VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR\">VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingMotionBlurFeaturesNV\">VkPhysicalDeviceRayTracingMotionBlurFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelineFeaturesKHR\">VkPhysicalDeviceRayTracingPipelineFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR\">VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG\">VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG</a>, <a href=\"#VkPhysicalDeviceRenderPassStripedFeaturesARM\">VkPhysicalDeviceRenderPassStripedFeaturesARM</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2FeaturesEXT\">VkPhysicalDeviceRobustness2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeatures\">VkPhysicalDeviceScalarBlockLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceSchedulingControlsFeaturesARM\">VkPhysicalDeviceSchedulingControlsFeaturesARM</a>, <a href=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT\">VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloatFeaturesEXT\">VkPhysicalDeviceShaderAtomicFloatFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64Features\">VkPhysicalDeviceShaderAtomicInt64Features</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM\">VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD\">VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceShaderEnqueueFeaturesAMDX\">VkPhysicalDeviceShaderEnqueueFeaturesAMDX</a>, <a href=\"#VkPhysicalDeviceShaderExpectAssumeFeaturesKHR\">VkPhysicalDeviceShaderExpectAssumeFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderFloat16Int8Features\">VkPhysicalDeviceShaderFloat16Int8Features</a>, <a href=\"#VkPhysicalDeviceShaderFloatControls2FeaturesKHR\">VkPhysicalDeviceShaderFloatControls2FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT\">VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerDotProductFeatures\">VkPhysicalDeviceShaderIntegerDotProductFeatures</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\">VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL</a>, <a href=\"#VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR\">VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT\">VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderObjectFeaturesEXT\">VkPhysicalDeviceShaderObjectFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderQuadControlFeaturesKHR\">VkPhysicalDeviceShaderQuadControlFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR\">VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR\">VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderTerminateInvocationFeatures\">VkPhysicalDeviceShaderTerminateInvocationFeatures</a>, <a href=\"#VkPhysicalDeviceShaderTileImageFeaturesEXT\">VkPhysicalDeviceShaderTileImageFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeatures\">VkPhysicalDeviceSubgroupSizeControlFeatures</a>, <a href=\"#VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT\">VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSubpassShadingFeaturesHUAWEI\">VkPhysicalDeviceSubpassShadingFeaturesHUAWEI</a>, <a href=\"#VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT\">VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSynchronization2Features\">VkPhysicalDeviceSynchronization2Features</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeatures\">VkPhysicalDeviceTextureCompressionASTCHDRFeatures</a>, <a href=\"#VkPhysicalDeviceTilePropertiesFeaturesQCOM\">VkPhysicalDeviceTilePropertiesFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeatures\">VkPhysicalDeviceTimelineSemaphoreFeatures</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeatures\">VkPhysicalDeviceUniformBufferStandardLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR\">VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT\">VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVideoMaintenance1FeaturesKHR\">VkPhysicalDeviceVideoMaintenance1FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a>, <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>, <a href=\"#VkPhysicalDeviceVulkan13Features\">VkPhysicalDeviceVulkan13Features</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeatures\">VkPhysicalDeviceVulkanMemoryModelFeatures</a>, <a href=\"#VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR\">VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT\">VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceYcbcrDegammaFeaturesQCOM\">VkPhysicalDeviceYcbcrDegammaFeaturesQCOM</a>, <a href=\"#VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\">VkPhysicalDeviceYcbcrImageArraysFeaturesEXT</a>, or <a href=\"#VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures\">VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures</a>",
           "page": "vkspec"
         },
         {
@@ -1626,7 +1626,7 @@
         },
         {
           "vuid": "VUID-VkCommandBufferInheritanceInfo-pNext-pNext",
-          "text": "Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkAttachmentSampleCountInfoAMD\">VkAttachmentSampleCountInfoAMD</a>, <a href=\"#VkCommandBufferInheritanceConditionalRenderingInfoEXT\">VkCommandBufferInheritanceConditionalRenderingInfoEXT</a>, <a href=\"#VkCommandBufferInheritanceRenderPassTransformInfoQCOM\">VkCommandBufferInheritanceRenderPassTransformInfoQCOM</a>, <a href=\"#VkCommandBufferInheritanceRenderingInfo\">VkCommandBufferInheritanceRenderingInfo</a>, <a href=\"#VkCommandBufferInheritanceViewportScissorInfoNV\">VkCommandBufferInheritanceViewportScissorInfoNV</a>, <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a>, or <a href=\"#VkMultiviewPerViewAttributesInfoNVX\">VkMultiviewPerViewAttributesInfoNVX</a>",
+          "text": "Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkAttachmentSampleCountInfoAMD\">VkAttachmentSampleCountInfoAMD</a>, <a href=\"#VkCommandBufferInheritanceConditionalRenderingInfoEXT\">VkCommandBufferInheritanceConditionalRenderingInfoEXT</a>, <a href=\"#VkCommandBufferInheritanceRenderPassTransformInfoQCOM\">VkCommandBufferInheritanceRenderPassTransformInfoQCOM</a>, <a href=\"#VkCommandBufferInheritanceRenderingInfo\">VkCommandBufferInheritanceRenderingInfo</a>, <a href=\"#VkCommandBufferInheritanceViewportScissorInfoNV\">VkCommandBufferInheritanceViewportScissorInfoNV</a>, <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a>, <a href=\"#VkMultiviewPerViewAttributesInfoNVX\">VkMultiviewPerViewAttributesInfoNVX</a>, <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>, or <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
           "page": "vkspec"
         },
         {
@@ -2954,6 +2954,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-09504",
+          "text": "If <code>vkCmdExecuteCommands</code> is being called within a render pass instance begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, the color attachment mapping state specified by <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a> in the inheritance info of each element of <code>pCommandBuffers</code> and in the current state of <code>commandBuffer</code> <strong class=\"purple\">must</strong> match",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-09505",
+          "text": "If <code>vkCmdExecuteCommands</code> is being called within a render pass instance begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, the input attachment mapping state specified by <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a> in the inheritance info of each element of <code>pCommandBuffers</code> and in the current state of <code>commandBuffer</code> <strong class=\"purple\">must</strong> match",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-parameter",
           "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle",
           "page": "vkspec"
@@ -4503,6 +4513,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkSetEvent-event-09543",
+          "text": "<code>event</code> <strong class=\"purple\">must</strong> not be waited on by a command buffer in the <a href=\"#commandbuffers-lifecycle\">pending state</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkSetEvent-device-parameter",
           "text": "<code>device</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDevice\">VkDevice</a> handle",
           "page": "vkspec"
@@ -5365,7 +5380,7 @@
         },
         {
           "vuid": "VUID-vkCmdPipelineBarrier2-dependencyFlags-07891",
-          "text": "If <code>vkCmdPipelineBarrier2</code> is called within a render pass instance, and and the source stage masks of any memory barriers include <a href=\"#synchronization-framebuffer-regions\">framebuffer-space stages</a>, then <code>dependencyFlags</code> <strong class=\"purple\">must</strong> include <code>VK_DEPENDENCY_BY_REGION_BIT</code>",
+          "text": "If <code>vkCmdPipelineBarrier2</code> is called within a render pass instance, and the source stage masks of any memory barriers include <a href=\"#synchronization-framebuffer-regions\">framebuffer-space stages</a>, then <code>dependencyFlags</code> <strong class=\"purple\">must</strong> include <code>VK_DEPENDENCY_BY_REGION_BIT</code>",
           "page": "vkspec"
         },
         {
@@ -5384,13 +5399,23 @@
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCmdPipelineBarrier2-shaderTileImageColorReadAccess-08718",
-          "text": "If <code>vkCmdPipelineBarrier2</code> is called within a render pass instance and none of the <a href=\"#features-shaderTileImageColorReadAccess\"><code>shaderTileImageColorReadAccess</code></a>, <a href=\"#features-shaderTileImageDepthReadAccess\"><code>shaderTileImageDepthReadAccess</code></a>, <a href=\"#features-shaderTileImageStencilReadAccess\"><code>shaderTileImageStencilReadAccess</code></a> features are enabled, the render pass <strong class=\"purple\">must</strong> not have been started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>",
+          "vuid": "VUID-vkCmdPipelineBarrier2-None-09553",
+          "text": "If     neither the <a href=\"#features-shaderTileImageColorReadAccess\"><code>shaderTileImageColorReadAccess</code></a> nor     <a href=\"#features-shaderTileImageDepthReadAccess\"><code>shaderTileImageDepthReadAccess</code></a> features are enabled, and     the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled,     <code>vkCmdPipelineBarrier2</code> <strong class=\"purple\">must</strong> not be called within a render pass instance     started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>",
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCmdPipelineBarrier2-None-08719",
-          "text": "If <code>vkCmdPipelineBarrier2</code> is called within a render pass instance started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, it <strong class=\"purple\">must</strong> adhere to the restrictions in <a href=\"#synchronization-pipeline-barriers-explicit-renderpass-tileimage\">Explicit Render Pass Tile Image Access Synchronization</a>",
+          "vuid": "VUID-vkCmdPipelineBarrier2-None-09554",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, and <code>vkCmdPipelineBarrier2</code> is called within a render pass instance started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, there <strong class=\"purple\">must</strong> be no buffer or image memory barriers specified by this command",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier2-image-09555",
+          "text": "If <code>vkCmdPipelineBarrier2</code> is called within a render pass instance started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and the <code>image</code> member of any image memory barrier is used as an attachment in the current render pass instance, it <strong class=\"purple\">must</strong> be in the <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code> or <code>VK_IMAGE_LAYOUT_GENERAL</code> layout",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier2-srcStageMask-09556",
+          "text": "If <code>vkCmdPipelineBarrier2</code> is called within a render pass instance started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, this command <strong class=\"purple\">must</strong> only specify <a href=\"#synchronization-framebuffer-regions\">framebuffer-space stages</a> in <code>srcStageMask</code> and <code>dstStageMask</code>",
           "page": "vkspec"
         },
         {
@@ -5614,7 +5639,7 @@
         },
         {
           "vuid": "VUID-vkCmdPipelineBarrier-dependencyFlags-07891",
-          "text": "If <code>vkCmdPipelineBarrier</code> is called within a render pass instance, and and the source stage masks of any memory barriers include <a href=\"#synchronization-framebuffer-regions\">framebuffer-space stages</a>, then <code>dependencyFlags</code> <strong class=\"purple\">must</strong> include <code>VK_DEPENDENCY_BY_REGION_BIT</code>",
+          "text": "If <code>vkCmdPipelineBarrier</code> is called within a render pass instance, and the source stage masks of any memory barriers include <a href=\"#synchronization-framebuffer-regions\">framebuffer-space stages</a>, then <code>dependencyFlags</code> <strong class=\"purple\">must</strong> include <code>VK_DEPENDENCY_BY_REGION_BIT</code>",
           "page": "vkspec"
         },
         {
@@ -5633,13 +5658,23 @@
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCmdPipelineBarrier-shaderTileImageColorReadAccess-08718",
-          "text": "If <code>vkCmdPipelineBarrier</code> is called within a render pass instance and none of the <a href=\"#features-shaderTileImageColorReadAccess\"><code>shaderTileImageColorReadAccess</code></a>, <a href=\"#features-shaderTileImageDepthReadAccess\"><code>shaderTileImageDepthReadAccess</code></a>, <a href=\"#features-shaderTileImageStencilReadAccess\"><code>shaderTileImageStencilReadAccess</code></a> features are enabled, the render pass <strong class=\"purple\">must</strong> not have been started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>",
+          "vuid": "VUID-vkCmdPipelineBarrier-None-09553",
+          "text": "If     neither the <a href=\"#features-shaderTileImageColorReadAccess\"><code>shaderTileImageColorReadAccess</code></a> nor     <a href=\"#features-shaderTileImageDepthReadAccess\"><code>shaderTileImageDepthReadAccess</code></a> features are enabled, and     the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled,     <code>vkCmdPipelineBarrier</code> <strong class=\"purple\">must</strong> not be called within a render pass instance     started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>",
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCmdPipelineBarrier-None-08719",
-          "text": "If <code>vkCmdPipelineBarrier</code> is called within a render pass instance started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, it <strong class=\"purple\">must</strong> adhere to the restrictions in <a href=\"#synchronization-pipeline-barriers-explicit-renderpass-tileimage\">Explicit Render Pass Tile Image Access Synchronization</a>",
+          "vuid": "VUID-vkCmdPipelineBarrier-None-09554",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, and <code>vkCmdPipelineBarrier</code> is called within a render pass instance started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, there <strong class=\"purple\">must</strong> be no buffer or image memory barriers specified by this command",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier-image-09555",
+          "text": "If <code>vkCmdPipelineBarrier</code> is called within a render pass instance started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and the <code>image</code> member of any image memory barrier is used as an attachment in the current render pass instance, it <strong class=\"purple\">must</strong> be in the <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code> or <code>VK_IMAGE_LAYOUT_GENERAL</code> layout",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-09556",
+          "text": "If <code>vkCmdPipelineBarrier</code> is called within a render pass instance started with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, this command <strong class=\"purple\">must</strong> only specify <a href=\"#synchronization-framebuffer-regions\">framebuffer-space stages</a> in <code>srcStageMask</code> and <code>dstStageMask</code>",
           "page": "vkspec"
         },
         {
@@ -7683,6 +7718,21 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-09550",
+          "text": "If <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> define a <a href=\"#synchronization-queue-transfers\">queue family ownership transfer</a> or <code>oldLayout</code> and <code>newLayout</code> define an <a href=\"#synchronization-image-layout-transitions\">image layout transition</a>, and <code>oldLayout</code> or <code>newLayout</code> is <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code> then <code>image</code> <strong class=\"purple\">must</strong> have been created with either <code>VK_IMAGE_USAGE_STORAGE_BIT</code>, or with both <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code> and either of <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code> or <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkImageMemoryBarrier2-dynamicRenderingLocalRead-09551",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>oldLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkImageMemoryBarrier2-dynamicRenderingLocalRead-09552",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>newLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkImageMemoryBarrier2-subresourceRange-01486",
           "text": "<code>subresourceRange.baseMipLevel</code> <strong class=\"purple\">must</strong> be less than the <code>mipLevels</code> specified in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> when <code>image</code> was created",
           "page": "vkspec"
@@ -7982,6 +8032,21 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-09550",
+          "text": "If <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> define a <a href=\"#synchronization-queue-transfers\">queue family ownership transfer</a> or <code>oldLayout</code> and <code>newLayout</code> define an <a href=\"#synchronization-image-layout-transitions\">image layout transition</a>, and <code>oldLayout</code> or <code>newLayout</code> is <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code> then <code>image</code> <strong class=\"purple\">must</strong> have been created with either <code>VK_IMAGE_USAGE_STORAGE_BIT</code>, or with both <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code> and either of <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code> or <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkImageMemoryBarrier-dynamicRenderingLocalRead-09551",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>oldLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkImageMemoryBarrier-dynamicRenderingLocalRead-09552",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>newLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01486",
           "text": "<code>subresourceRange.baseMipLevel</code> <strong class=\"purple\">must</strong> be less than the <code>mipLevels</code> specified in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> when <code>image</code> was created",
           "page": "vkspec"
@@ -8729,7 +8794,12 @@
         },
         {
           "vuid": "VUID-VkRenderingInfo-resolveMode-09322",
-          "text": "If the <code>resolveMode</code> of any element of <code>pColorAttachments</code> is <code>VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID</code>, <a href=\"#VkRenderingFragmentShadingRateAttachmentInfoKHR\">VkRenderingFragmentShadingRateAttachmentInfoKHR</a>::<code>imageView</code> <strong class=\"purple\">must</strong> be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> If the <code>pNext</code> chain contains a <a href=\"#VkRenderPassStripeBeginInfoARM\">VkRenderPassStripeBeginInfoARM</a> structure, the union of stripe areas defined by the elements of <a href=\"#VkRenderPassStripeInfoARM\">VkRenderPassStripeInfoARM</a>::<code>pStripeInfos</code> <strong class=\"purple\">must</strong> cover the <code>renderArea</code>",
+          "text": "If the <code>resolveMode</code> of any element of <code>pColorAttachments</code> is <code>VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID</code>, <a href=\"#VkRenderingFragmentShadingRateAttachmentInfoKHR\">VkRenderingFragmentShadingRateAttachmentInfoKHR</a>::<code>imageView</code> <strong class=\"purple\">must</strong> be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingInfo-pNext-09535",
+          "text": "If the <code>pNext</code> chain contains a <a href=\"#VkRenderPassStripeBeginInfoARM\">VkRenderPassStripeBeginInfoARM</a> structure, the union of stripe areas defined by the elements of <a href=\"#VkRenderPassStripeInfoARM\">VkRenderPassStripeInfoARM</a>::<code>pStripeInfos</code> <strong class=\"purple\">must</strong> cover the <code>renderArea</code>",
           "page": "vkspec"
         },
         {
@@ -9647,6 +9717,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-VkAttachmentDescription-dynamicRenderingLocalRead-09544",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>initialLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkAttachmentDescription-dynamicRenderingLocalRead-09545",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>finalLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkAttachmentDescription-format-06698",
           "text": "<code>format</code> <strong class=\"purple\">must</strong> not be VK_FORMAT_UNDEFINED",
           "page": "vkspec"
@@ -10013,6 +10093,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-VkAttachmentReference-dynamicRenderingLocalRead-09546",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>layout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkAttachmentReference-layout-parameter",
           "text": "<code>layout</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkImageLayout\">VkImageLayout</a> value",
           "page": "vkspec"
@@ -10568,6 +10653,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-VkAttachmentDescription2-dynamicRenderingLocalRead-09544",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>initialLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkAttachmentDescription2-dynamicRenderingLocalRead-09545",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>finalLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkAttachmentDescription2-pNext-06704",
           "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkAttachmentDescriptionStencilLayout\">VkAttachmentDescriptionStencilLayout</a> structure, <code>format</code> includes a stencil component, and <code>stencilLoadOp</code> is <code>VK_ATTACHMENT_LOAD_OP_LOAD</code>, then <code>initialLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_UNDEFINED</code>",
           "page": "vkspec"
@@ -11207,6 +11302,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-VkAttachmentReference2-dynamicRenderingLocalRead-09546",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>layout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkAttachmentReference2-sType-sType",
           "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2</code>",
           "page": "vkspec"
@@ -11850,6 +11950,11 @@
     "VkFramebufferAttachmentImageInfo": {
       "core": [
         {
+          "vuid": "VUID-VkFramebufferAttachmentImageInfo-viewFormatCount-09536",
+          "text": "If <code>viewFormatCount</code> is not 0, each element of <code>pViewFormats</code> <strong class=\"purple\">must</strong> not be <code>VK_FORMAT_UNDEFINED</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkFramebufferAttachmentImageInfo-sType-sType",
           "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO</code>",
           "page": "vkspec"
@@ -11993,6 +12098,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-09537",
+          "text": "If any of the <code>initialLayout</code> or <code>finalLayout</code> member of the <code>VkAttachmentDescription</code> structures or the <code>layout</code> member of the <code>VkAttachmentReference</code> structures specified when creating the render pass specified in the <code>renderPass</code> member of <code>pRenderPassBegin</code> is <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code> then the corresponding attachment image view of the framebuffer specified in the <code>framebuffer</code> member of <code>pRenderPassBegin</code> <strong class=\"purple\">must</strong> have been created with a <code>usage</code> value including either <code>VK_IMAGE_USAGE_STORAGE_BIT</code>, or both <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code> and either of <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code> or <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-parameter",
           "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle",
           "page": "vkspec"
@@ -12112,6 +12222,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdBeginRenderPass2-initialLayout-09538",
+          "text": "If any of the <code>initialLayout</code> or <code>finalLayout</code> member of the <code>VkAttachmentDescription</code> structures or the <code>layout</code> member of the <code>VkAttachmentReference</code> structures specified when creating the render pass specified in the <code>renderPass</code> member of <code>pRenderPassBegin</code> is <code>VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR</code> then the corresponding attachment image view of the framebuffer specified in the <code>framebuffer</code> member of <code>pRenderPassBegin</code> <strong class=\"purple\">must</strong> have been created with a <code>usage</code> value including either <code>VK_IMAGE_USAGE_STORAGE_BIT</code>, or both <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code> and either of <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code> or <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdBeginRenderPass2-commandBuffer-parameter",
           "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle",
           "page": "vkspec"
@@ -12297,7 +12412,12 @@
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-perViewRenderAreaCount-07860",
-          "text": "If the <code>perViewRenderAreaCount</code> member of a <a href=\"#VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM\">VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM</a> structure included in the <code>pNext</code> chain is not <code>0</code>, then <code>renderArea</code> <strong class=\"purple\">must</strong> specify a render area that includes the union of all per view render areas. If the <code>pNext</code> chain contains a <a href=\"#VkRenderPassStripeBeginInfoARM\">VkRenderPassStripeBeginInfoARM</a> structure, the union of stripe areas defined by the elements of <a href=\"#VkRenderPassStripeInfoARM\">VkRenderPassStripeInfoARM</a>::<code>pStripeInfos</code> <strong class=\"purple\">must</strong> cover the <code>renderArea</code>",
+          "text": "If the <code>perViewRenderAreaCount</code> member of a <a href=\"#VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM\">VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM</a> structure included in the <code>pNext</code> chain is not <code>0</code>, then <code>renderArea</code> <strong class=\"purple\">must</strong> specify a render area that includes the union of all per view render areas.",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderPassBeginInfo-pNext-09539",
+          "text": "If the <code>pNext</code> chain contains a <a href=\"#VkRenderPassStripeBeginInfoARM\">VkRenderPassStripeBeginInfoARM</a> structure, the union of stripe areas defined by the elements of <a href=\"#VkRenderPassStripeInfoARM\">VkRenderPassStripeInfoARM</a>::<code>pStripeInfos</code> <strong class=\"purple\">must</strong> cover the <code>renderArea</code>",
           "page": "vkspec"
         },
         {
@@ -13232,7 +13352,7 @@
         },
         {
           "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08450",
-          "text": "If <code>codeType</code> is <code>VK_SHADER_CODE_TYPE_SPIRV_EXT</code>, and the identified entry point includes any variables in its interface that are declared with the <code>ClipDistance</code> or <code>CullDistance</code> <code>BuiltIn</code> decoration, those variables <strong class=\"purple\">must</strong> not have array sizes which sum to more than <code>VkPhysicalDeviceLimits</code>::<code>maxCombinedClipAndCullDistances</code>",
+          "text": "If <code>codeType</code> is <code>VK_SHADER_CODE_TYPE_SPIRV_EXT</code>, and the identified entry point includes variables in its interface that are declared with the <code>ClipDistance</code> <code>BuiltIn</code> decoration and variables in its interface that are declared with the <code>CullDistance</code> <code>BuiltIn</code> decoration, those variables <strong class=\"purple\">must</strong> not have array sizes which sum to more than <code>VkPhysicalDeviceLimits</code>::<code>maxCombinedClipAndCullDistances</code>",
           "page": "vkspec"
         },
         {
@@ -13564,7 +13684,7 @@
         },
         {
           "vuid": "VUID-vkDestroyShaderEXT-shader-parameter",
-          "text": "<code>shader</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkShaderEXT\">VkShaderEXT</a> handle",
+          "text": "If <code>shader</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>shader</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkShaderEXT\">VkShaderEXT</a> handle",
           "page": "vkspec"
         },
         {
@@ -13574,7 +13694,7 @@
         },
         {
           "vuid": "VUID-vkDestroyShaderEXT-shader-parent",
-          "text": "<code>shader</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from <code>device</code>",
+          "text": "If <code>shader</code> is a valid handle, it <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from <code>device</code>",
           "page": "vkspec"
         }
       ]
@@ -13880,31 +14000,6 @@
           "vuid": "VUID-VkCooperativeMatrixPropertiesKHR-pNext-pNext",
           "text": "<code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>",
           "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkCooperativeMatrixPropertiesKHR-AType-parameter",
-          "text": "<code>AType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkComponentTypeKHR\">VkComponentTypeKHR</a> value",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkCooperativeMatrixPropertiesKHR-BType-parameter",
-          "text": "<code>BType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkComponentTypeKHR\">VkComponentTypeKHR</a> value",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkCooperativeMatrixPropertiesKHR-CType-parameter",
-          "text": "<code>CType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkComponentTypeKHR\">VkComponentTypeKHR</a> value",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkCooperativeMatrixPropertiesKHR-ResultType-parameter",
-          "text": "<code>ResultType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkComponentTypeKHR\">VkComponentTypeKHR</a> value",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkCooperativeMatrixPropertiesKHR-scope-parameter",
-          "text": "<code>scope</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkScopeKHR\">VkScopeKHR</a> value",
-          "page": "vkspec"
         }
       ]
     },
@@ -13919,31 +14014,6 @@
           "vuid": "VUID-VkCooperativeMatrixPropertiesNV-pNext-pNext",
           "text": "<code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>",
           "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkCooperativeMatrixPropertiesNV-AType-parameter",
-          "text": "<code>AType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkComponentTypeNV\">VkComponentTypeNV</a> value",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkCooperativeMatrixPropertiesNV-BType-parameter",
-          "text": "<code>BType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkComponentTypeNV\">VkComponentTypeNV</a> value",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkCooperativeMatrixPropertiesNV-CType-parameter",
-          "text": "<code>CType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkComponentTypeNV\">VkComponentTypeNV</a> value",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkCooperativeMatrixPropertiesNV-DType-parameter",
-          "text": "<code>DType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkComponentTypeNV\">VkComponentTypeNV</a> value",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkCooperativeMatrixPropertiesNV-scope-parameter",
-          "text": "<code>scope</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkScopeNV\">VkScopeNV</a> value",
-          "page": "vkspec"
         }
       ]
     },
@@ -14557,7 +14627,7 @@
         },
         {
           "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710",
-          "text": "If the identified entry point includes any variables in its interface that are declared with the <code>ClipDistance</code> or <code>CullDistance</code> <code>BuiltIn</code> decoration, those variables <strong class=\"purple\">must</strong> not have array sizes which sum to more than <code>VkPhysicalDeviceLimits</code>::<code>maxCombinedClipAndCullDistances</code>",
+          "text": "If the identified entry point includes variables in its interface that are declared with the <code>ClipDistance</code> <code>BuiltIn</code> decoration and variables in its interface that are declared with the <code>CullDistance</code> <code>BuiltIn</code> decoration, those variables <strong class=\"purple\">must</strong> not have array sizes which sum to more than <code>VkPhysicalDeviceLimits</code>::<code>maxCombinedClipAndCullDistances</code>",
           "page": "vkspec"
         },
         {
@@ -15518,12 +15588,12 @@
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766",
-          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-pre-rasterization\">pre-rasterization shader state</a> and at least one of <a href=\"#pipelines-graphics-subsets-fragment-output\">fragment output interface state</a> or <a href=\"#pipelines-graphics-subsets-fragment-shader\">fragment shader state</a>, and <code>pMultisampleState</code> is not <code>NULL</code>, the <code>lineRasterizationMode</code> member of a <a href=\"#VkPipelineRasterizationLineStateCreateInfoEXT\">VkPipelineRasterizationLineStateCreateInfoEXT</a> structure included in the <code>pNext</code> chain of <code>pRasterizationState</code> is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code> or <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <code>alphaToCoverageEnable</code>, <code>alphaToOneEnable</code>, and <code>sampleShadingEnable</code> members of <code>pMultisampleState</code> <strong class=\"purple\">must</strong> all be <code>VK_FALSE</code>",
+          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-pre-rasterization\">pre-rasterization shader state</a> and at least one of <a href=\"#pipelines-graphics-subsets-fragment-output\">fragment output interface state</a> or <a href=\"#pipelines-graphics-subsets-fragment-shader\">fragment shader state</a>, and <code>pMultisampleState</code> is not <code>NULL</code>, the <code>lineRasterizationMode</code> member of a <a href=\"#VkPipelineRasterizationLineStateCreateInfoKHR\">VkPipelineRasterizationLineStateCreateInfoKHR</a> structure included in the <code>pNext</code> chain of <code>pRasterizationState</code> is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code> or <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <code>alphaToCoverageEnable</code>, <code>alphaToOneEnable</code>, and <code>sampleShadingEnable</code> members of <code>pMultisampleState</code> <strong class=\"purple\">must</strong> all be <code>VK_FALSE</code>",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767",
-          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-pre-rasterization\">pre-rasterization shader state</a>, the <code>stippledLineEnable</code> member of <a href=\"#VkPipelineRasterizationLineStateCreateInfoEXT\">VkPipelineRasterizationLineStateCreateInfoEXT</a> is <code>VK_TRUE</code>, and no element of the <code>pDynamicStates</code> member of <code>pDynamicState</code> is <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code>, then the <code>lineStippleFactor</code> member of <a href=\"#VkPipelineRasterizationLineStateCreateInfoEXT\">VkPipelineRasterizationLineStateCreateInfoEXT</a> <strong class=\"purple\">must</strong> be in the range <span class=\"eq\">[1,256]</span>",
+          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-pre-rasterization\">pre-rasterization shader state</a>, the <code>stippledLineEnable</code> member of <a href=\"#VkPipelineRasterizationLineStateCreateInfoKHR\">VkPipelineRasterizationLineStateCreateInfoKHR</a> is <code>VK_TRUE</code>, and no element of the <code>pDynamicStates</code> member of <code>pDynamicState</code> is <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code>, then the <code>lineStippleFactor</code> member of <a href=\"#VkPipelineRasterizationLineStateCreateInfoKHR\">VkPipelineRasterizationLineStateCreateInfoKHR</a> <strong class=\"purple\">must</strong> be in the range <span class=\"eq\">[1,256]</span>",
           "page": "vkspec"
         },
         {
@@ -15953,7 +16023,7 @@
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06061",
-          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-shader\">fragment shader state</a> and <code>renderPass</code> is <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, fragment shaders in <code>pStages</code> <strong class=\"purple\">must</strong> not include the <code>InputAttachment</code> capability",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-shader\">fragment shader state</a>, and <code>renderPass</code> is <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, fragment shaders in <code>pStages</code> <strong class=\"purple\">must</strong> not include the <code>InputAttachment</code> capability",
           "page": "vkspec"
         },
         {
@@ -15978,12 +16048,12 @@
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06482",
-          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-output\">fragment output interface state</a> and the <code>flags</code> member of <a href=\"#VkPipelineColorBlendStateCreateInfo\">VkPipelineColorBlendStateCreateInfo</a> includes <code>VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT</code>, <code>renderpass</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-output\">fragment output interface state</a>, and the <code>flags</code> member of <a href=\"#VkPipelineColorBlendStateCreateInfo\">VkPipelineColorBlendStateCreateInfo</a> includes <code>VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT</code>, <code>renderPass</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>",
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06483",
-          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-output\">fragment output interface state</a> and the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> includes <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT</code> or <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT</code>, <code>renderpass</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>",
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-None-09526",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-output\">fragment output interface state</a>, and the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> includes <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT</code> or <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT</code>, <code>renderPass</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>",
           "page": "vkspec"
         },
         {
@@ -15997,18 +16067,18 @@
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06484",
-          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-output\">fragment output interface state</a> and the <code>flags</code> member of <a href=\"#VkPipelineColorBlendStateCreateInfo\">VkPipelineColorBlendStateCreateInfo</a> includes <code>VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT</code> <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT</code>",
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-09527",
+          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-output\">fragment output interface state</a>, <code>renderPass</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, and the <code>flags</code> member of <a href=\"#VkPipelineColorBlendStateCreateInfo\">VkPipelineColorBlendStateCreateInfo</a> includes <code>VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT</code> <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT</code>",
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06485",
-          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-shader\">fragment shader state</a> and the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> includes <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT</code>, <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT</code>",
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-09528",
+          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-shader\">fragment shader state</a>, <code>renderPass</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, and the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> includes <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT</code>, <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT</code>",
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06486",
-          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-shader\">fragment shader state</a> and the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> includes <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT</code>, <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT</code>",
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-09529",
+          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-fragment-shader\">fragment shader state</a>, <code>renderPass</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, and the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> includes <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT</code>, <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT</code>",
           "page": "vkspec"
         },
         {
@@ -16067,8 +16137,8 @@
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-stageCount-06604",
-          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-pre-rasterization\">pre-rasterization shader state</a> or <a href=\"#pipelines-graphics-subsets-fragment-shader\">fragment shader state</a>, <code>stageCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>",
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-stageCount-09530",
+          "text": "If the pipeline requires <a href=\"#pipelines-graphics-subsets-pre-rasterization\">pre-rasterization shader state</a>, <code>stageCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>",
           "page": "vkspec"
         },
         {
@@ -16248,12 +16318,12 @@
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-pLibraries-06636",
-          "text": "If one element of <a href=\"#VkPipelineLibraryCreateInfoKHR\">VkPipelineLibraryCreateInfoKHR</a>::<code>pLibraries</code> was created with <code>VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT</code> and a value of <code>pMultisampleState-&gt;sampleShading</code> equal <code>VK_TRUE</code>, and if a different element of <a href=\"#VkPipelineLibraryCreateInfoKHR\">VkPipelineLibraryCreateInfoKHR</a>::<code>pLibraries</code> was created with <code>VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT</code>, the <code>pMultisampleState</code> used to create each library <strong class=\"purple\">must</strong> be <em>identically defined</em>",
+          "text": "If one element of <a href=\"#VkPipelineLibraryCreateInfoKHR\">VkPipelineLibraryCreateInfoKHR</a>::<code>pLibraries</code> was created with <code>VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT</code> and a value of <code>pMultisampleState-&gt;sampleShadingEnable</code> equal <code>VK_TRUE</code>, and if a different element of <a href=\"#VkPipelineLibraryCreateInfoKHR\">VkPipelineLibraryCreateInfoKHR</a>::<code>pLibraries</code> was created with <code>VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT</code>, the <code>pMultisampleState</code> used to create each library <strong class=\"purple\">must</strong> be <em>identically defined</em>",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06637",
-          "text": "If <a href=\"#VkGraphicsPipelineLibraryCreateInfoEXT\">VkGraphicsPipelineLibraryCreateInfoEXT</a>::<code>flags</code> includes <code>VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT</code>, <code>pMultisampleState-&gt;sampleShading</code> is <code>VK_TRUE</code>, and an element of <a href=\"#VkPipelineLibraryCreateInfoKHR\">VkPipelineLibraryCreateInfoKHR</a>::<code>pLibraries</code> was created with <code>VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT</code>, the <code>pMultisampleState</code> used to create that library <strong class=\"purple\">must</strong> be <em>identically defined</em> <code>pMultisampleState</code>",
+          "text": "If <a href=\"#VkGraphicsPipelineLibraryCreateInfoEXT\">VkGraphicsPipelineLibraryCreateInfoEXT</a>::<code>flags</code> includes <code>VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT</code>, <code>pMultisampleState-&gt;sampleShadingEnable</code> is <code>VK_TRUE</code>, and an element of <a href=\"#VkPipelineLibraryCreateInfoKHR\">VkPipelineLibraryCreateInfoKHR</a>::<code>pLibraries</code> was created with <code>VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT</code>, the <code>pMultisampleState</code> used to create that library <strong class=\"purple\">must</strong> be <em>identically defined</em> <code>pMultisampleState</code>",
           "page": "vkspec"
         },
         {
@@ -16667,13 +16737,23 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-09531",
+          "text": "If the pipeline is being created with <a href=\"#pipelines-graphics-subsets-fragment-shader\">fragment shader state</a> and <a href=\"#pipelines-graphics-subsets-fragment-output\">fragment output state</a>, and the value of <code>renderPass</code> is <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>::<code>colorAttachmentCount</code> <strong class=\"purple\">must</strong> be equal to <a href=\"#VkPipelineRenderingCreateInfo\">VkPipelineRenderingCreateInfo</a>::<code>colorAttachmentCount</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-09532",
+          "text": "If the pipeline is being created with <a href=\"#pipelines-graphics-subsets-fragment-output\">fragment output state</a>, and the value of <code>renderPass</code> is <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>colorAttachmentCount</code> <strong class=\"purple\">must</strong> be equal to <a href=\"#VkPipelineRenderingCreateInfo\">VkPipelineRenderingCreateInfo</a>::<code>colorAttachmentCount</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-sType-sType",
           "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO</code>",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-pNext-pNext",
-          "text": "Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkAttachmentSampleCountInfoAMD\">VkAttachmentSampleCountInfoAMD</a>, <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a>, <a href=\"#VkGraphicsPipelineLibraryCreateInfoEXT\">VkGraphicsPipelineLibraryCreateInfoEXT</a>, <a href=\"#VkGraphicsPipelineShaderGroupsCreateInfoNV\">VkGraphicsPipelineShaderGroupsCreateInfoNV</a>, <a href=\"#VkMultiviewPerViewAttributesInfoNVX\">VkMultiviewPerViewAttributesInfoNVX</a>, <a href=\"#VkPipelineCompilerControlCreateInfoAMD\">VkPipelineCompilerControlCreateInfoAMD</a>, <a href=\"#VkPipelineCreateFlags2CreateInfoKHR\">VkPipelineCreateFlags2CreateInfoKHR</a>, <a href=\"#VkPipelineCreationFeedbackCreateInfo\">VkPipelineCreationFeedbackCreateInfo</a>, <a href=\"#VkPipelineDiscardRectangleStateCreateInfoEXT\">VkPipelineDiscardRectangleStateCreateInfoEXT</a>, <a href=\"#VkPipelineFragmentShadingRateEnumStateCreateInfoNV\">VkPipelineFragmentShadingRateEnumStateCreateInfoNV</a>, <a href=\"#VkPipelineFragmentShadingRateStateCreateInfoKHR\">VkPipelineFragmentShadingRateStateCreateInfoKHR</a>, <a href=\"#VkPipelineLibraryCreateInfoKHR\">VkPipelineLibraryCreateInfoKHR</a>, <a href=\"#VkPipelineRenderingCreateInfo\">VkPipelineRenderingCreateInfo</a>, <a href=\"#VkPipelineRepresentativeFragmentTestStateCreateInfoNV\">VkPipelineRepresentativeFragmentTestStateCreateInfoNV</a>, or <a href=\"#VkPipelineRobustnessCreateInfoEXT\">VkPipelineRobustnessCreateInfoEXT</a>",
+          "text": "Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkAttachmentSampleCountInfoAMD\">VkAttachmentSampleCountInfoAMD</a>, <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a>, <a href=\"#VkGraphicsPipelineLibraryCreateInfoEXT\">VkGraphicsPipelineLibraryCreateInfoEXT</a>, <a href=\"#VkGraphicsPipelineShaderGroupsCreateInfoNV\">VkGraphicsPipelineShaderGroupsCreateInfoNV</a>, <a href=\"#VkMultiviewPerViewAttributesInfoNVX\">VkMultiviewPerViewAttributesInfoNVX</a>, <a href=\"#VkPipelineCompilerControlCreateInfoAMD\">VkPipelineCompilerControlCreateInfoAMD</a>, <a href=\"#VkPipelineCreateFlags2CreateInfoKHR\">VkPipelineCreateFlags2CreateInfoKHR</a>, <a href=\"#VkPipelineCreationFeedbackCreateInfo\">VkPipelineCreationFeedbackCreateInfo</a>, <a href=\"#VkPipelineDiscardRectangleStateCreateInfoEXT\">VkPipelineDiscardRectangleStateCreateInfoEXT</a>, <a href=\"#VkPipelineFragmentShadingRateEnumStateCreateInfoNV\">VkPipelineFragmentShadingRateEnumStateCreateInfoNV</a>, <a href=\"#VkPipelineFragmentShadingRateStateCreateInfoKHR\">VkPipelineFragmentShadingRateStateCreateInfoKHR</a>, <a href=\"#VkPipelineLibraryCreateInfoKHR\">VkPipelineLibraryCreateInfoKHR</a>, <a href=\"#VkPipelineRenderingCreateInfo\">VkPipelineRenderingCreateInfo</a>, <a href=\"#VkPipelineRepresentativeFragmentTestStateCreateInfoNV\">VkPipelineRepresentativeFragmentTestStateCreateInfoNV</a>, <a href=\"#VkPipelineRobustnessCreateInfoEXT\">VkPipelineRobustnessCreateInfoEXT</a>, <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>, or <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
           "page": "vkspec"
         },
         {
@@ -16696,6 +16776,11 @@
     "VkPipelineRenderingCreateInfo": {
       "core": [
         {
+          "vuid": "VUID-VkPipelineRenderingCreateInfo-colorAttachmentCount-09533",
+          "text": "<code>colorAttachmentCount</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#limits-maxColorAttachments\"><code>maxColorAttachments</code></a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkPipelineRenderingCreateInfo-sType-sType",
           "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO</code>",
           "page": "vkspec"
@@ -16954,11 +17039,6 @@
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCreateRayTracingPipelinesKHR-deferredOperation-03677",
-          "text": "If <code>deferredOperation</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDeferredOperationKHR\">VkDeferredOperationKHR</a> object",
-          "page": "vkspec"
-        },
-        {
           "vuid": "VUID-vkCreateRayTracingPipelinesKHR-deferredOperation-03678",
           "text": "Any previous deferred operation that was associated with <code>deferredOperation</code> <strong class=\"purple\">must</strong> be complete",
           "page": "vkspec"
@@ -20915,12 +20995,12 @@
       "core": [
         {
           "vuid": "VUID-VkBufferCreateInfo-None-09499",
-          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code>: must be a valid combination of <a href=\"#VkBufferUsageFlagBits\">VkBufferUsageFlagBits</a> values",
+          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code> must be a valid combination of <a href=\"#VkBufferUsageFlagBits\">VkBufferUsageFlagBits</a> values",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkBufferCreateInfo-None-09500",
-          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code>: must not be 0",
+          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code> must not be 0",
           "page": "vkspec"
         },
         {
@@ -22238,6 +22318,11 @@
     "VkImageFormatListCreateInfo": {
       "core": [
         {
+          "vuid": "VUID-VkImageFormatListCreateInfo-viewFormatCount-09540",
+          "text": "If <code>viewFormatCount</code> is not 0, each element of <code>pViewFormats</code> <strong class=\"purple\">must</strong> not be <code>VK_FORMAT_UNDEFINED</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkImageFormatListCreateInfo-sType-sType",
           "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO</code>",
           "page": "vkspec"
@@ -24399,6 +24484,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkGetAccelerationStructureDeviceAddressKHR-pInfo-09541",
+          "text": "If the buffer on which <code>pInfo-&gt;accelerationStructure</code> was placed is non-sparse then it <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <code>VkDeviceMemory</code> object",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkGetAccelerationStructureDeviceAddressKHR-pInfo-09542",
+          "text": "The buffer on which <code>pInfo-&gt;accelerationStructure</code> was placed <strong class=\"purple\">must</strong> have been created with the <code>VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT</code> usage flag",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkGetAccelerationStructureDeviceAddressKHR-device-parameter",
           "text": "<code>device</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDevice\">VkDevice</a> handle",
           "page": "vkspec"
@@ -26056,46 +26151,6 @@
           "vuid": "VUID-VkBufferCollectionPropertiesFUCHSIA-pNext-pNext",
           "text": "<code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>",
           "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkBufferCollectionPropertiesFUCHSIA-formatFeatures-parameter",
-          "text": "<code>formatFeatures</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkFormatFeatureFlagBits\">VkFormatFeatureFlagBits</a> values",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkBufferCollectionPropertiesFUCHSIA-formatFeatures-requiredbitmask",
-          "text": "<code>formatFeatures</code> <strong class=\"purple\">must</strong> not be <code>0</code>",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkBufferCollectionPropertiesFUCHSIA-sysmemColorSpaceIndex-parameter",
-          "text": "<code>sysmemColorSpaceIndex</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSysmemColorSpaceFUCHSIA\">VkSysmemColorSpaceFUCHSIA</a> structure",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkBufferCollectionPropertiesFUCHSIA-samplerYcbcrConversionComponents-parameter",
-          "text": "<code>samplerYcbcrConversionComponents</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkComponentMapping\">VkComponentMapping</a> structure",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkBufferCollectionPropertiesFUCHSIA-suggestedYcbcrModel-parameter",
-          "text": "<code>suggestedYcbcrModel</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSamplerYcbcrModelConversion\">VkSamplerYcbcrModelConversion</a> value",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkBufferCollectionPropertiesFUCHSIA-suggestedYcbcrRange-parameter",
-          "text": "<code>suggestedYcbcrRange</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSamplerYcbcrRange\">VkSamplerYcbcrRange</a> value",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkBufferCollectionPropertiesFUCHSIA-suggestedXChromaOffset-parameter",
-          "text": "<code>suggestedXChromaOffset</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkChromaLocation\">VkChromaLocation</a> value",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkBufferCollectionPropertiesFUCHSIA-suggestedYChromaOffset-parameter",
-          "text": "<code>suggestedYChromaOffset</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkChromaLocation\">VkChromaLocation</a> value",
-          "page": "vkspec"
         }
       ]
     },
@@ -28132,6 +28187,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-VkWriteDescriptorSet-descriptorType-09506",
+          "text": "If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code>, <code>dstSet</code> was allocated with a layout that included immutable samplers for <code>dstBinding</code>, and those samplers enable <a href=\"#samplers-YCbCr-conversion\">sampler Y′C<sub>B</sub>C<sub>R</sub> conversion</a>, then <code>imageView</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00327",
           "text": "If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER</code> or <code>VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC</code>, the <code>offset</code> member of each element of <code>pBufferInfo</code> <strong class=\"purple\">must</strong> be a multiple of <code>VkPhysicalDeviceLimits</code>::<code>minUniformBufferOffsetAlignment</code>",
           "page": "vkspec"
@@ -29748,6 +29808,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkGetDescriptorEXT-pDescriptorInfo-09507",
+          "text": "If <code>pDescriptorInfo-&gt;type</code> is <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code> and <code>pDescriptorInfo-&gt;data.pCombinedImageSampler</code> is <code>NULL</code> or it has a <code>imageView</code> that is <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> then <code>dataSize</code> <strong class=\"purple\">must</strong> be equal to the size of <a href=\"#VkPhysicalDeviceDescriptorBufferPropertiesEXT\">VkPhysicalDeviceDescriptorBufferPropertiesEXT</a>::<code>combinedImageSamplerDescriptorSize</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkGetDescriptorEXT-device-parameter",
           "text": "<code>device</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDevice\">VkDevice</a> handle",
           "page": "vkspec"
@@ -29975,6 +30040,11 @@
     "VkDescriptorAddressInfoEXT": {
       "core": [
         {
+          "vuid": "VUID-VkDescriptorAddressInfoEXT-None-09508",
+          "text": "If <code>address</code> is not zero, and the descriptor is of type <code>VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER</code> or <code>VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER</code>, then <code>format</code> <strong class=\"purple\">must</strong> not be <code>VK_FORMAT_UNDEFINED</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkDescriptorAddressInfoEXT-address-08043",
           "text": "If the <a href=\"#features-nullDescriptor\"><code>nullDescriptor</code></a> feature is not enabled, <code>address</code> <strong class=\"purple\">must</strong> not be zero",
           "page": "vkspec"
@@ -30104,12 +30174,12 @@
       "core": [
         {
           "vuid": "VUID-VkDescriptorBufferBindingInfoEXT-None-09499",
-          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code>: must be a valid combination of <a href=\"#VkBufferUsageFlagBits\">VkBufferUsageFlagBits</a> values",
+          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code> must be a valid combination of <a href=\"#VkBufferUsageFlagBits\">VkBufferUsageFlagBits</a> values",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkDescriptorBufferBindingInfoEXT-None-09500",
-          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code>: must not be 0",
+          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code> must not be 0",
           "page": "vkspec"
         },
         {
@@ -30896,6 +30966,192 @@
         }
       ]
     },
+    "vkCmdSetRenderingAttachmentLocationsKHR": {
+      "core": [
+        {
+          "vuid": "VUID-vkCmdSetRenderingAttachmentLocationsKHR-dynamicRenderingLocalRead-09509",
+          "text": "<a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> <strong class=\"purple\">must</strong> be enabled",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingAttachmentLocationsKHR-pLocationInfo-09510",
+          "text": "<code>pLocationInfo-&gt;colorAttachmentCount</code> <strong class=\"purple\">must</strong> be equal to the value of <a href=\"#VkRenderingInfo\">VkRenderingInfo</a>::<code>colorAttachmentCount</code> used to begin the current render pass instance",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingAttachmentLocationsKHR-commandBuffer-09511",
+          "text": "The current render pass instance <strong class=\"purple\">must</strong> have been started or resumed by <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a> in this <code>commandBuffer</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingAttachmentLocationsKHR-commandBuffer-parameter",
+          "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingAttachmentLocationsKHR-pLocationInfo-parameter",
+          "text": "<code>pLocationInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a> structure",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingAttachmentLocationsKHR-commandBuffer-recording",
+          "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingAttachmentLocationsKHR-commandBuffer-cmdpool",
+          "text": "The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingAttachmentLocationsKHR-renderpass",
+          "text": "This command <strong class=\"purple\">must</strong> only be called inside of a render pass instance",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingAttachmentLocationsKHR-videocoding",
+          "text": "This command <strong class=\"purple\">must</strong> only be called outside of a video coding scope",
+          "page": "vkspec"
+        }
+      ]
+    },
+    "VkRenderingAttachmentLocationInfoKHR": {
+      "core": [
+        {
+          "vuid": "VUID-VkRenderingAttachmentLocationInfoKHR-dynamicRenderingLocalRead-09512",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, and <code>pColorAttachmentLocations</code> is not <code>NULL</code>, each element <strong class=\"purple\">must</strong> be set to the value of its index within the array",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingAttachmentLocationInfoKHR-pColorAttachmentLocations-09513",
+          "text": "Elements of <code>pColorAttachmentLocations</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> each be unique",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingAttachmentLocationInfoKHR-colorAttachmentCount-09514",
+          "text": "<code>colorAttachmentCount</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#limits-maxColorAttachments\"><code>maxColorAttachments</code></a>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingAttachmentLocationInfoKHR-pColorAttachmentLocations-09515",
+          "text": "Each element of <code>pColorAttachmentLocations</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#limits-maxColorAttachments\"><code>maxColorAttachments</code></a>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingAttachmentLocationInfoKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR</code>",
+          "page": "vkspec"
+        }
+      ]
+    },
+    "vkCmdSetRenderingInputAttachmentIndicesKHR": {
+      "core": [
+        {
+          "vuid": "VUID-vkCmdSetRenderingInputAttachmentIndicesKHR-dynamicRenderingLocalRead-09516",
+          "text": "<a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> <strong class=\"purple\">must</strong> be enabled",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingInputAttachmentIndicesKHR-pInputAttachmentIndexInfo-09517",
+          "text": "<code>pInputAttachmentIndexInfo-&gt;colorAttachmentCount</code> <strong class=\"purple\">must</strong> be equal to the value of <a href=\"#VkRenderingInfo\">VkRenderingInfo</a>::<code>colorAttachmentCount</code> used to begin the current render pass instance",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingInputAttachmentIndicesKHR-commandBuffer-09518",
+          "text": "The current render pass instance <strong class=\"purple\">must</strong> have been started or resumed by <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a> in this <code>commandBuffer</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingInputAttachmentIndicesKHR-commandBuffer-parameter",
+          "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingInputAttachmentIndicesKHR-pLocationInfo-parameter",
+          "text": "<code>pLocationInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a> structure",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingInputAttachmentIndicesKHR-commandBuffer-recording",
+          "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingInputAttachmentIndicesKHR-commandBuffer-cmdpool",
+          "text": "The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingInputAttachmentIndicesKHR-renderpass",
+          "text": "This command <strong class=\"purple\">must</strong> only be called inside of a render pass instance",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRenderingInputAttachmentIndicesKHR-videocoding",
+          "text": "This command <strong class=\"purple\">must</strong> only be called outside of a video coding scope",
+          "page": "vkspec"
+        }
+      ]
+    },
+    "VkRenderingInputAttachmentIndexInfoKHR": {
+      "core": [
+        {
+          "vuid": "VUID-VkRenderingInputAttachmentIndexInfoKHR-dynamicRenderingLocalRead-09519",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, and <code>pColorAttachmentInputIndices</code> is not <code>NULL</code>, each element <strong class=\"purple\">must</strong> be set to <code>VK_ATTACHMENT_UNUSED</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingInputAttachmentIndexInfoKHR-dynamicRenderingLocalRead-09520",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>pDepthInputAttachmentIndex</code> <strong class=\"purple\">must</strong> be a valid pointer to a value of <code>VK_ATTACHMENT_UNUSED</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingInputAttachmentIndexInfoKHR-dynamicRenderingLocalRead-09521",
+          "text": "If the <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> feature is not enabled, <code>pStencilInputAttachmentIndex</code> <strong class=\"purple\">must</strong> be a valid pointer to a value of <code>VK_ATTACHMENT_UNUSED</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingInputAttachmentIndexInfoKHR-pColorAttachmentInputIndices-09522",
+          "text": "Elements of <code>pColorAttachmentInputIndices</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> each be unique",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingInputAttachmentIndexInfoKHR-pColorAttachmentInputIndices-09523",
+          "text": "Elements of <code>pColorAttachmentInputIndices</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> not take the same value as the content of <code>pDepthInputAttachmentIndex</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingInputAttachmentIndexInfoKHR-pColorAttachmentInputIndices-09524",
+          "text": "Elements of <code>pColorAttachmentInputIndices</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> not take the same value as the content of <code>pStencilInputAttachmentIndex</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingInputAttachmentIndexInfoKHR-colorAttachmentCount-09525",
+          "text": "<code>colorAttachmentCount</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#limits-maxColorAttachments\"><code>maxColorAttachments</code></a>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingInputAttachmentIndexInfoKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingInputAttachmentIndexInfoKHR-pColorAttachmentInputIndices-parameter",
+          "text": "If <code>colorAttachmentCount</code> is not <code>0</code>, and <code>pColorAttachmentInputIndices</code> is not <code>NULL</code>, <code>pColorAttachmentInputIndices</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>colorAttachmentCount</code> <code>uint32_t</code> values",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingInputAttachmentIndexInfoKHR-pDepthInputAttachmentIndex-parameter",
+          "text": "If <code>pDepthInputAttachmentIndex</code> is not <code>NULL</code>, <code>pDepthInputAttachmentIndex</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>uint32_t</code> value",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkRenderingInputAttachmentIndexInfoKHR-pStencilInputAttachmentIndex-parameter",
+          "text": "If <code>pStencilInputAttachmentIndex</code> is not <code>NULL</code>, <code>pStencilInputAttachmentIndex</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>uint32_t</code> value",
+          "page": "vkspec"
+        }
+      ]
+    },
     "BaryCoordKHR": {
       "core": [
         {
@@ -33210,6 +33466,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-VkQueryPoolCreateInfo-queryType-09534",
+          "text": "If <code>queryType</code> is <code>VK_QUERY_TYPE_PIPELINE_STATISTICS</code>, <code>pipelineStatistics</code> <strong class=\"purple\">must</strong> not be zero",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkQueryPoolCreateInfo-queryType-03222",
           "text": "If <code>queryType</code> is <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkQueryPoolPerformanceCreateInfoKHR\">VkQueryPoolPerformanceCreateInfoKHR</a> structure",
           "page": "vkspec"
@@ -35199,6 +35460,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdClearAttachments-colorAttachment-09503",
+          "text": "The <code>colorAttachment</code> member of each element of <code>pAttachments</code> <strong class=\"purple\">must</strong> not identify a color attachment that is currently mapped to <code>VK_ATTACHMENT_UNUSED</code> in <code>commandBuffer</code> via <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdClearAttachments-aspectMask-09298",
           "text": "If the subpass this is recorded in performs an external format resolve, the <code>aspectMask</code> member of any element of <code>pAttachments</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_ASPECT_PLANE<em>_i_</em>BIT</code> for any index <em>i</em>",
           "page": "vkspec"
@@ -40792,7 +41058,7 @@
         },
         {
           "vuid": "VUID-vkCmdBindIndexBuffer-indexType-08787",
-          "text": "If <code>indexType</code> is <code>VK_INDEX_TYPE_UINT8_EXT</code>, the <a href=\"#features-indexTypeUint8\"><code>indexTypeUint8</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If <code>indexType</code> is <code>VK_INDEX_TYPE_UINT8_KHR</code>, the <a href=\"#features-indexTypeUint8\"><code>indexTypeUint8</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
@@ -40871,7 +41137,7 @@
         },
         {
           "vuid": "VUID-vkCmdBindIndexBuffer2KHR-indexType-08787",
-          "text": "If <code>indexType</code> is <code>VK_INDEX_TYPE_UINT8_EXT</code>, the <a href=\"#features-indexTypeUint8\"><code>indexTypeUint8</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If <code>indexType</code> is <code>VK_INDEX_TYPE_UINT8_KHR</code>, the <a href=\"#features-indexTypeUint8\"><code>indexTypeUint8</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
@@ -42120,17 +42386,17 @@
         },
         {
           "vuid": "VUID-vkCmdDraw-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDraw-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDraw-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -42140,27 +42406,27 @@
         },
         {
           "vuid": "VUID-vkCmdDraw-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDraw-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDraw-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDraw-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDraw-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -42445,22 +42711,22 @@
         },
         {
           "vuid": "VUID-vkCmdDraw-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDraw-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDraw-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDraw-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -42589,6 +42855,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDraw-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDraw-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDraw-commandBuffer-02712",
           "text": "If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource",
           "page": "vkspec"
@@ -43914,17 +44190,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -43934,27 +44210,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -44239,22 +44515,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -44383,6 +44659,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawIndexed-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexed-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02712",
           "text": "If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource",
           "page": "vkspec"
@@ -45723,17 +46009,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -45743,27 +46029,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -46048,22 +46334,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiEXT-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -46192,6 +46478,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawMultiEXT-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMultiEXT-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-02712",
           "text": "If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource",
           "page": "vkspec"
@@ -47537,17 +47833,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -47557,27 +47853,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -47862,22 +48158,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -48006,6 +48302,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-02712",
           "text": "If <code>commandBuffer</code> is a protected command buffer and <a href=\"#limits-protectedNoFault\"><code>protectedNoFault</code></a> is not supported, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource",
           "page": "vkspec"
@@ -49371,17 +49677,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -49391,27 +49697,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -49696,22 +50002,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -49840,6 +50146,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawIndirect-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirect-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawIndirect-None-04007",
           "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound",
           "page": "vkspec"
@@ -51219,17 +51535,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -51239,27 +51555,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -51544,22 +51860,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -51688,6 +52004,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawIndirectCount-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectCount-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawIndirectCount-None-04007",
           "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound",
           "page": "vkspec"
@@ -53073,17 +53399,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -53093,27 +53419,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -53398,22 +53724,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -53542,6 +53868,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawIndexedIndirect-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirect-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04007",
           "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound",
           "page": "vkspec"
@@ -54936,17 +55272,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -54956,27 +55292,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -55261,22 +55597,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -55405,6 +55741,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04007",
           "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound",
           "page": "vkspec"
@@ -56800,17 +57146,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -56820,27 +57166,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -57125,22 +57471,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -57269,6 +57615,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04007",
           "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound",
           "page": "vkspec"
@@ -58751,17 +59107,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -58771,27 +59127,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -59076,22 +59432,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -59220,6 +59576,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-stage-06480",
           "text": "The bound graphics pipeline <strong class=\"purple\">must</strong> not have been created with the <a href=\"#VkPipelineShaderStageCreateInfo\">VkPipelineShaderStageCreateInfo</a>::<code>stage</code> member of an element of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>pStages</code> set to <code>VK_SHADER_STAGE_VERTEX_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>",
           "page": "vkspec"
@@ -60465,17 +60831,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -60485,27 +60851,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -60790,22 +61156,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -60934,6 +61300,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-stage-06480",
           "text": "The bound graphics pipeline <strong class=\"purple\">must</strong> not have been created with the <a href=\"#VkPipelineShaderStageCreateInfo\">VkPipelineShaderStageCreateInfo</a>::<code>stage</code> member of an element of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>pStages</code> set to <code>VK_SHADER_STAGE_VERTEX_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>",
           "page": "vkspec"
@@ -62238,17 +62614,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -62258,27 +62634,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -62563,22 +62939,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -62707,6 +63083,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-stage-06480",
           "text": "The bound graphics pipeline <strong class=\"purple\">must</strong> not have been created with the <a href=\"#VkPipelineShaderStageCreateInfo\">VkPipelineShaderStageCreateInfo</a>::<code>stage</code> member of an element of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>pStages</code> set to <code>VK_SHADER_STAGE_VERTEX_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>",
           "page": "vkspec"
@@ -64032,17 +64418,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -64052,27 +64438,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -64357,22 +64743,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -64501,6 +64887,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawMeshTasksEXT-stage-06480",
           "text": "The bound graphics pipeline <strong class=\"purple\">must</strong> not have been created with the <a href=\"#VkPipelineShaderStageCreateInfo\">VkPipelineShaderStageCreateInfo</a>::<code>stage</code> member of an element of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>pStages</code> set to <code>VK_SHADER_STAGE_VERTEX_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>",
           "page": "vkspec"
@@ -65781,17 +66177,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -65801,27 +66197,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -66106,22 +66502,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -66250,6 +66646,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-stage-06480",
           "text": "The bound graphics pipeline <strong class=\"purple\">must</strong> not have been created with the <a href=\"#VkPipelineShaderStageCreateInfo\">VkPipelineShaderStageCreateInfo</a>::<code>stage</code> member of an element of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>pStages</code> set to <code>VK_SHADER_STAGE_VERTEX_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>",
           "page": "vkspec"
@@ -67589,17 +67995,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -67609,27 +68015,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -67914,22 +68320,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -68058,6 +68464,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-stage-06480",
           "text": "The bound graphics pipeline <strong class=\"purple\">must</strong> not have been created with the <a href=\"#VkPipelineShaderStageCreateInfo\">VkPipelineShaderStageCreateInfo</a>::<code>stage</code> member of an element of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>pStages</code> set to <code>VK_SHADER_STAGE_VERTEX_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>",
           "page": "vkspec"
@@ -69383,17 +69799,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -69403,27 +69819,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -69708,22 +70124,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -69852,6 +70268,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawClusterHUAWEI-stage-06480",
           "text": "The bound graphics pipeline <strong class=\"purple\">must</strong> not have been created with the <a href=\"#VkPipelineShaderStageCreateInfo\">VkPipelineShaderStageCreateInfo</a>::<code>stage</code> member of an element of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>pStages</code> set to <code>VK_SHADER_STAGE_VERTEX_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>",
           "page": "vkspec"
@@ -71112,17 +71538,17 @@
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -71132,27 +71558,27 @@
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -71437,22 +71863,22 @@
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -71581,6 +72007,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-stage-06480",
           "text": "The bound graphics pipeline <strong class=\"purple\">must</strong> not have been created with the <a href=\"#VkPipelineShaderStageCreateInfo\">VkPipelineShaderStageCreateInfo</a>::<code>stage</code> member of an element of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>pStages</code> set to <code>VK_SHADER_STAGE_VERTEX_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>",
           "page": "vkspec"
@@ -73198,7 +73634,7 @@
         },
         {
           "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext",
-          "text": "Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDepthBiasRepresentationInfoEXT\">VkDepthBiasRepresentationInfoEXT</a>, <a href=\"#VkPipelineRasterizationConservativeStateCreateInfoEXT\">VkPipelineRasterizationConservativeStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationDepthClipStateCreateInfoEXT\">VkPipelineRasterizationDepthClipStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationLineStateCreateInfoEXT\">VkPipelineRasterizationLineStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationProvokingVertexStateCreateInfoEXT\">VkPipelineRasterizationProvokingVertexStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationStateRasterizationOrderAMD\">VkPipelineRasterizationStateRasterizationOrderAMD</a>, or <a href=\"#VkPipelineRasterizationStateStreamCreateInfoEXT\">VkPipelineRasterizationStateStreamCreateInfoEXT</a>",
+          "text": "Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDepthBiasRepresentationInfoEXT\">VkDepthBiasRepresentationInfoEXT</a>, <a href=\"#VkPipelineRasterizationConservativeStateCreateInfoEXT\">VkPipelineRasterizationConservativeStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationDepthClipStateCreateInfoEXT\">VkPipelineRasterizationDepthClipStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationLineStateCreateInfoKHR\">VkPipelineRasterizationLineStateCreateInfoKHR</a>, <a href=\"#VkPipelineRasterizationProvokingVertexStateCreateInfoEXT\">VkPipelineRasterizationProvokingVertexStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationStateRasterizationOrderAMD\">VkPipelineRasterizationStateRasterizationOrderAMD</a>, or <a href=\"#VkPipelineRasterizationStateStreamCreateInfoEXT\">VkPipelineRasterizationStateStreamCreateInfoEXT</a>",
           "page": "vkspec"
         },
         {
@@ -74097,51 +74533,51 @@
         }
       ]
     },
-    "VkPipelineRasterizationLineStateCreateInfoEXT": {
+    "VkPipelineRasterizationLineStateCreateInfoKHR": {
       "core": [
         {
           "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02768",
-          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-rectangularLines\"><code>rectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-rectangularLines\"><code>rectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769",
-          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-bresenhamLines\"><code>bresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-bresenhamLines\"><code>bresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02770",
-          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-smoothLines\"><code>smoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-smoothLines\"><code>smoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02771",
-          "text": "If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02772",
-          "text": "If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02773",
-          "text": "If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02774",
-          "text": "If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-sType-sType",
-          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT</code>",
+          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR</code>",
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-parameter",
-          "text": "<code>lineRasterizationMode</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLineRasterizationModeEXT\">VkLineRasterizationModeEXT</a> value",
+          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoKHR-lineRasterizationMode-parameter",
+          "text": "<code>lineRasterizationMode</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLineRasterizationModeKHR\">VkLineRasterizationModeKHR</a> value",
           "page": "vkspec"
         }
       ]
@@ -74155,17 +74591,17 @@
         },
         {
           "vuid": "VUID-vkCmdSetLineRasterizationModeEXT-lineRasterizationMode-07418",
-          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-rectangularLines\"><code>rectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-rectangularLines\"><code>rectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdSetLineRasterizationModeEXT-lineRasterizationMode-07419",
-          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-bresenhamLines\"><code>bresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-bresenhamLines\"><code>bresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdSetLineRasterizationModeEXT-lineRasterizationMode-07420",
-          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-smoothLines\"><code>smoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-smoothLines\"><code>smoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
@@ -74253,7 +74689,7 @@
         }
       ]
     },
-    "vkCmdSetLineStippleEXT": {
+    "vkCmdSetLineStippleKHR": {
       "core": [
         {
           "vuid": "VUID-vkCmdSetLineStippleEXT-lineStippleFactor-02776",
@@ -74261,22 +74697,22 @@
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCmdSetLineStippleEXT-commandBuffer-parameter",
+          "vuid": "VUID-vkCmdSetLineStippleKHR-commandBuffer-parameter",
           "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle",
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCmdSetLineStippleEXT-commandBuffer-recording",
+          "vuid": "VUID-vkCmdSetLineStippleKHR-commandBuffer-recording",
           "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>",
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCmdSetLineStippleEXT-commandBuffer-cmdpool",
+          "vuid": "VUID-vkCmdSetLineStippleKHR-commandBuffer-cmdpool",
           "text": "The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations",
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCmdSetLineStippleEXT-videocoding",
+          "vuid": "VUID-vkCmdSetLineStippleKHR-videocoding",
           "text": "This command <strong class=\"purple\">must</strong> only be called outside of a video coding scope",
           "page": "vkspec"
         }
@@ -78472,7 +78908,7 @@
         },
         {
           "vuid": "VUID-VkGeneratedCommandsMemoryRequirementsInfoNV-pipelineBindPoint-09077",
-          "text": "If <code>pipelineBindPoint</code> is of type <code>VK_PIPELINE_BIND_POINT_COMPUTE</code>, and the <code>indirectCommandsLayout</code> contains a <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV</code> token, then the <code>pipeline</code> <strong class=\"purple\">must</strong> be <code>NULL</code>",
+          "text": "If <code>pipelineBindPoint</code> is of type <code>VK_PIPELINE_BIND_POINT_COMPUTE</code>, and the <code>indirectCommandsLayout</code> contains a <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV</code> token, then the <code>pipeline</code> <strong class=\"purple\">must</strong> be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>",
           "page": "vkspec"
         },
         {
@@ -79783,17 +80219,17 @@
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08666",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08667",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08668",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineRasterizationModeEXT\">vkCmdSetLineRasterizationModeEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -79803,27 +80239,27 @@
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08669",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPolygonModeEXT\">vkCmdSetPolygonModeEXT</a> in the current command buffer set <code>polygonMode</code> to <code>VK_POLYGON_MODE_LINE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08670",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to the <code>VK_SHADER_STAGE_VERTEX_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetPrimitiveTopology\">vkCmdSetPrimitiveTopology</a> in the current command buffer set <code>primitiveTopology</code> to any line topology, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08671",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object that outputs line primitives is bound to the <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code> or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code> stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, then <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07849",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_KHR</code>     dynamic state enabled then <a href=\"#vkCmdSetLineStippleKHR\">vkCmdSetLineStippleKHR</a>     <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this     drawing command",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08672",
-          "text": "If the <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
+          "text": "If the <code><a href=\"#VK_KHR_line_rasterization\">VK_KHR_line_rasterization</a></code> or <code><a href=\"#VK_EXT_line_rasterization\">VK_EXT_line_rasterization</a></code> extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to <a href=\"#vkCmdSetRasterizerDiscardEnable\">vkCmdSetRasterizerDiscardEnable</a> in the current command buffer set <code>rasterizerDiscardEnable</code> to <code>VK_FALSE</code>, and the most recent call to <a href=\"#vkCmdSetLineStippleEnableEXT\">vkCmdSetLineStippleEnableEXT</a> in the current command buffer set <code>stippledLineEnable</code> to <code>VK_TRUE</code>, then <a href=\"#vkCmdSetLineStippleEXT\">vkCmdSetLineStippleEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this drawing command",
           "page": "vkspec"
         },
         {
@@ -80108,22 +80544,22 @@
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-stippledLineEnable-07495",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-stippledLineEnable-07496",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR</code>, then the <a href=\"#features-stippledBresenhamLines\"><code>stippledBresenhamLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-stippledLineEnable-07497",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR</code>, then the <a href=\"#features-stippledSmoothLines\"><code>stippledSmoothLines</code></a> feature <strong class=\"purple\">must</strong> be enabled",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-stippledLineEnable-07498",
-          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
+          "text": "If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT</code> or <code>VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT</code> dynamic states enabled, and if the current <code>stippledLineEnable</code> state is <code>VK_TRUE</code> and the current <code>lineRasterizationMode</code> state is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR</code>, then the <a href=\"#features-stippledRectangularLines\"><code>stippledRectangularLines</code></a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>",
           "page": "vkspec"
         },
         {
@@ -80252,6 +80688,16 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-09548",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, the value of each element of <a href=\"#VkRenderingAttachmentLocationInfoKHR\">VkRenderingAttachmentLocationInfoKHR</a>::<code>pColorAttachmentLocations</code> set by <a href=\"#vkCmdSetRenderingAttachmentLocationsKHR\">vkCmdSetRenderingAttachmentLocationsKHR</a> <strong class=\"purple\">must</strong> match the value set for the corresponding element in the currently bound pipeline",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-09549",
+          "text": "If the current render pass was begun with <a href=\"#vkCmdBeginRendering\">vkCmdBeginRendering</a>, and there is no shader object bound to any graphics stage, input attachment index mappings in the currently bound pipeline <strong class=\"purple\">must</strong> match those set for the current render pass instance via <a href=\"#VkRenderingInputAttachmentIndexInfoKHR\">VkRenderingInputAttachmentIndexInfoKHR</a>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04007",
           "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound",
           "page": "vkspec"
@@ -80625,7 +81071,7 @@
       "core": [
         {
           "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-01094",
-          "text": "<code>samples</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSampleCountFlagBits\">VkSampleCountFlagBits</a> value that is set in <code>VkImageFormatProperties</code>::<code>sampleCounts</code> returned by <code>vkGetPhysicalDeviceImageFormatProperties</code> with <code>format</code>, <code>type</code>, <code>tiling</code>, and <code>usage</code> equal to those in this command and <code>flags</code> equal to the value that is set in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> when the image is created",
+          "text": "<code>samples</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSampleCountFlagBits\">VkSampleCountFlagBits</a> value that is set in <code>VkImageFormatProperties</code>::<code>sampleCounts</code> returned by <code>vkGetPhysicalDeviceImageFormatProperties</code> with <code>format</code>, <code>type</code>, <code>tiling</code>, and <code>usage</code> equal to those in this command",
           "page": "vkspec"
         },
         {
@@ -80703,7 +81149,7 @@
       "core": [
         {
           "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095",
-          "text": "<code>samples</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSampleCountFlagBits\">VkSampleCountFlagBits</a> value that is set in <code>VkImageFormatProperties</code>::<code>sampleCounts</code> returned by <code>vkGetPhysicalDeviceImageFormatProperties</code> with <code>format</code>, <code>type</code>, <code>tiling</code>, and <code>usage</code> equal to those in this command and <code>flags</code> equal to the value that is set in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> when the image is created",
+          "text": "<code>samples</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSampleCountFlagBits\">VkSampleCountFlagBits</a> value that is set in <code>VkImageFormatProperties</code>::<code>sampleCounts</code> returned by <code>vkGetPhysicalDeviceImageFormatProperties</code> with <code>format</code>, <code>type</code>, <code>tiling</code>, and <code>usage</code> equal to those in this command",
           "page": "vkspec"
         },
         {
@@ -85418,6 +85864,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-commandBuffer-09547",
+          "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> not be a protected command buffer",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03675",
           "text": "For each <code>pInfos</code>[i], <code>dstAccelerationStructure</code> <strong class=\"purple\">must</strong> have been created with a value of <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a>::<code>size</code> greater than or equal to the memory size required by the build operation, as returned by <a href=\"#vkGetAccelerationStructureBuildSizesKHR\">vkGetAccelerationStructureBuildSizesKHR</a> with <span class=\"eq\"><code>pBuildInfo</code> = <code>pInfos</code>[i]</span> and with each element of the <code>pMaxPrimitiveCounts</code> array greater than or equal to the equivalent <code>ppBuildRangeInfos</code>[i][j].<code>primitiveCount</code> values for <code>j</code> in <span class=\"eq\">[0,<code>pInfos</code>[i].<code>geometryCount</code>)</span>",
           "page": "vkspec"
@@ -85782,6 +86233,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-commandBuffer-09547",
+          "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> not be a protected command buffer",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pIndirectDeviceAddresses-03645",
           "text": "For any element of <code>pIndirectDeviceAddresses</code>, if the buffer from which it was queried is non-sparse then it <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <a href=\"#VkDeviceMemory\">VkDeviceMemory</a> object",
           "page": "vkspec"
@@ -85807,11 +86263,6 @@
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-commandBuffer-03649",
-          "text": "<code>commandBuffer</code> <strong class=\"purple\">must</strong> not be a protected command buffer",
-          "page": "vkspec"
-        },
-        {
           "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pIndirectDeviceAddresses-03651",
           "text": "Each <a href=\"#VkAccelerationStructureBuildRangeInfoKHR\">VkAccelerationStructureBuildRangeInfoKHR</a> structure referenced by any element of <code>pIndirectDeviceAddresses</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkAccelerationStructureBuildRangeInfoKHR\">VkAccelerationStructureBuildRangeInfoKHR</a> structure",
           "page": "vkspec"
@@ -86121,6 +86572,16 @@
     "VkAccelerationStructureTrianglesDisplacementMicromapNV": {
       "core": [
         {
+          "vuid": "VUID-VkAccelerationStructureTrianglesDisplacementMicromapNV-displacementBiasAndScaleFormat-09501",
+          "text": "<code>displacementBiasAndScaleFormat</code> <strong class=\"purple\">must</strong> not be <code>VK_FORMAT_UNDEFINED</code>",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-VkAccelerationStructureTrianglesDisplacementMicromapNV-displacementVectorFormat-09502",
+          "text": "<code>displacementVectorFormat</code> <strong class=\"purple\">must</strong> not be <code>VK_FORMAT_UNDEFINED</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-VkAccelerationStructureTrianglesDisplacementMicromapNV-pUsageCounts-07992",
           "text": "Only one of <code>pUsageCounts</code> or <code>ppUsageCounts</code> <strong class=\"purple\">can</strong> be a valid pointer, the other <strong class=\"purple\">must</strong> be <code>NULL</code>",
           "page": "vkspec"
@@ -87120,11 +87581,6 @@
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkBuildAccelerationStructuresKHR-deferredOperation-03677",
-          "text": "If <code>deferredOperation</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDeferredOperationKHR\">VkDeferredOperationKHR</a> object",
-          "page": "vkspec"
-        },
-        {
           "vuid": "VUID-vkBuildAccelerationStructuresKHR-deferredOperation-03678",
           "text": "Any previous deferred operation that was associated with <code>deferredOperation</code> <strong class=\"purple\">must</strong> be complete",
           "page": "vkspec"
@@ -87244,11 +87700,6 @@
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCopyAccelerationStructureKHR-deferredOperation-03677",
-          "text": "If <code>deferredOperation</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDeferredOperationKHR\">VkDeferredOperationKHR</a> object",
-          "page": "vkspec"
-        },
-        {
           "vuid": "VUID-vkCopyAccelerationStructureKHR-deferredOperation-03678",
           "text": "Any previous deferred operation that was associated with <code>deferredOperation</code> <strong class=\"purple\">must</strong> be complete",
           "page": "vkspec"
@@ -87303,11 +87754,6 @@
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-deferredOperation-03677",
-          "text": "If <code>deferredOperation</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDeferredOperationKHR\">VkDeferredOperationKHR</a> object",
-          "page": "vkspec"
-        },
-        {
           "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-deferredOperation-03678",
           "text": "Any previous deferred operation that was associated with <code>deferredOperation</code> <strong class=\"purple\">must</strong> be complete",
           "page": "vkspec"
@@ -87362,11 +87808,6 @@
           "page": "vkspec"
         },
         {
-          "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-deferredOperation-03677",
-          "text": "If <code>deferredOperation</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDeferredOperationKHR\">VkDeferredOperationKHR</a> object",
-          "page": "vkspec"
-        },
-        {
           "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-deferredOperation-03678",
           "text": "Any previous deferred operation that was associated with <code>deferredOperation</code> <strong class=\"purple\">must</strong> be complete",
           "page": "vkspec"
@@ -88281,11 +88722,6 @@
     "vkCopyMicromapEXT": {
       "core": [
         {
-          "vuid": "VUID-vkCopyMicromapEXT-deferredOperation-03677",
-          "text": "If <code>deferredOperation</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDeferredOperationKHR\">VkDeferredOperationKHR</a> object",
-          "page": "vkspec"
-        },
-        {
           "vuid": "VUID-vkCopyMicromapEXT-deferredOperation-03678",
           "text": "Any previous deferred operation that was associated with <code>deferredOperation</code> <strong class=\"purple\">must</strong> be complete",
           "page": "vkspec"
@@ -88340,11 +88776,6 @@
     "vkCopyMemoryToMicromapEXT": {
       "core": [
         {
-          "vuid": "VUID-vkCopyMemoryToMicromapEXT-deferredOperation-03677",
-          "text": "If <code>deferredOperation</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDeferredOperationKHR\">VkDeferredOperationKHR</a> object",
-          "page": "vkspec"
-        },
-        {
           "vuid": "VUID-vkCopyMemoryToMicromapEXT-deferredOperation-03678",
           "text": "Any previous deferred operation that was associated with <code>deferredOperation</code> <strong class=\"purple\">must</strong> be complete",
           "page": "vkspec"
@@ -88399,11 +88830,6 @@
     "vkCopyMicromapToMemoryEXT": {
       "core": [
         {
-          "vuid": "VUID-vkCopyMicromapToMemoryEXT-deferredOperation-03677",
-          "text": "If <code>deferredOperation</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDeferredOperationKHR\">VkDeferredOperationKHR</a> object",
-          "page": "vkspec"
-        },
-        {
           "vuid": "VUID-vkCopyMicromapToMemoryEXT-deferredOperation-03678",
           "text": "Any previous deferred operation that was associated with <code>deferredOperation</code> <strong class=\"purple\">must</strong> be complete",
           "page": "vkspec"
@@ -97299,11 +97725,11 @@
         }
       ]
     },
-    "VkPhysicalDeviceIndexTypeUint8FeaturesEXT": {
+    "VkPhysicalDeviceIndexTypeUint8FeaturesKHR": {
       "core": [
         {
-          "vuid": "VUID-VkPhysicalDeviceIndexTypeUint8FeaturesEXT-sType-sType",
-          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT</code>",
+          "vuid": "VUID-VkPhysicalDeviceIndexTypeUint8FeaturesKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR</code>",
           "page": "vkspec"
         }
       ]
@@ -97380,11 +97806,11 @@
         }
       ]
     },
-    "VkPhysicalDeviceLineRasterizationFeaturesEXT": {
+    "VkPhysicalDeviceLineRasterizationFeaturesKHR": {
       "core": [
         {
-          "vuid": "VUID-VkPhysicalDeviceLineRasterizationFeaturesEXT-sType-sType",
-          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT</code>",
+          "vuid": "VUID-VkPhysicalDeviceLineRasterizationFeaturesKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR</code>",
           "page": "vkspec"
         }
       ]
@@ -98065,6 +98491,15 @@
         }
       ]
     },
+    "VkPhysicalDeviceShaderFloatControls2FeaturesKHR": {
+      "core": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceShaderFloatControls2FeaturesKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR</code>",
+          "page": "vkspec"
+        }
+      ]
+    },
     "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD": {
       "core": [
         {
@@ -98344,6 +98779,15 @@
         }
       ]
     },
+    "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR": {
+      "core": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR</code>",
+          "page": "vkspec"
+        }
+      ]
+    },
     "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID": {
       "core": [
         {
@@ -98380,6 +98824,42 @@
         }
       ]
     },
+    "VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR": {
+      "core": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR</code>",
+          "page": "vkspec"
+        }
+      ]
+    },
+    "VkPhysicalDeviceShaderExpectAssumeFeaturesKHR": {
+      "core": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceShaderExpectAssumeFeaturesKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR</code>",
+          "page": "vkspec"
+        }
+      ]
+    },
+    "VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR": {
+      "core": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR</code>",
+          "page": "vkspec"
+        }
+      ]
+    },
+    "VkPhysicalDeviceShaderQuadControlFeaturesKHR": {
+      "core": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceShaderQuadControlFeaturesKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR</code>",
+          "page": "vkspec"
+        }
+      ]
+    },
     "VkPhysicalDevicePushDescriptorPropertiesKHR": {
       "core": [
         {
@@ -98767,11 +99247,11 @@
         }
       ]
     },
-    "VkPhysicalDeviceLineRasterizationPropertiesEXT": {
+    "VkPhysicalDeviceLineRasterizationPropertiesKHR": {
       "core": [
         {
-          "vuid": "VUID-VkPhysicalDeviceLineRasterizationPropertiesEXT-sType-sType",
-          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT</code>",
+          "vuid": "VUID-VkPhysicalDeviceLineRasterizationPropertiesKHR-sType-sType",
+          "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR</code>",
           "page": "vkspec"
         }
       ]
@@ -99545,12 +100025,12 @@
       "core": [
         {
           "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-None-09499",
-          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code>: must be a valid combination of <a href=\"#VkBufferUsageFlagBits\">VkBufferUsageFlagBits</a> values",
+          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code> must be a valid combination of <a href=\"#VkBufferUsageFlagBits\">VkBufferUsageFlagBits</a> values",
           "page": "vkspec"
         },
         {
           "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-None-09500",
-          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code>: must not be 0",
+          "text": "If the <code>pNext</code> chain does not include a <a href=\"#VkBufferUsageFlags2CreateInfoKHR\">VkBufferUsageFlags2CreateInfoKHR</a> structure, <code>usage</code> must not be 0",
           "page": "vkspec"
         },
         {
@@ -100038,11 +100518,6 @@
     "VkDebugUtilsMessengerCreateInfoEXT": {
       "core": [
         {
-          "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-01914",
-          "text": "<code>pfnUserCallback</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#PFN_vkDebugUtilsMessengerCallbackEXT\">PFN_vkDebugUtilsMessengerCallbackEXT</a>",
-          "page": "vkspec"
-        },
-        {
           "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-sType-sType",
           "text": "<code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT</code>",
           "page": "vkspec"
@@ -100117,7 +100592,7 @@
         },
         {
           "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessage-parameter",
-          "text": "<code>pMessage</code> <strong class=\"purple\">must</strong> be a null-terminated UTF-8 string",
+          "text": "If <code>pMessage</code> is not <code>NULL</code>, <code>pMessage</code> <strong class=\"purple\">must</strong> be a null-terminated UTF-8 string",
           "page": "vkspec"
         },
         {
@@ -100731,16 +101206,6 @@
           "vuid": "VUID-VkDeviceFaultInfoEXT-pNext-pNext",
           "text": "<code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>",
           "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkDeviceFaultInfoEXT-pAddressInfos-parameter",
-          "text": "If <code>pAddressInfos</code> is not <code>NULL</code>, <code>pAddressInfos</code> <strong class=\"purple\">must</strong> be a valid pointer to a <a href=\"#VkDeviceFaultAddressInfoEXT\">VkDeviceFaultAddressInfoEXT</a> structure",
-          "page": "vkspec"
-        },
-        {
-          "vuid": "VUID-VkDeviceFaultInfoEXT-pVendorInfos-parameter",
-          "text": "If <code>pVendorInfos</code> is not <code>NULL</code>, <code>pVendorInfos</code> <strong class=\"purple\">must</strong> be a valid pointer to a <a href=\"#VkDeviceFaultVendorInfoEXT\">VkDeviceFaultVendorInfoEXT</a> structure",
-          "page": "vkspec"
         }
       ]
     },
@@ -101127,6 +101592,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-StandaloneSpirv-Input-09557",
+          "text": "The pointers of any <code>Input</code> or <code>Output</code> <a href=\"#interfaces-iointerfaces-user\">Interface user-defined variables</a> <strong class=\"purple\">must</strong> not contain any <code>PhysicalStorageBuffer</code> <code>Storage</code> <code>Class</code> pointers",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-StandaloneSpirv-GLSLShared-04669",
           "text": "The <code>GLSLShared</code> and <code>GLSLPacked</code> decorations <strong class=\"purple\">must</strong> not be used",
           "page": "vkspec"
@@ -101521,6 +101991,11 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-RuntimeSpirv-None-09558",
+          "text": "If <a href=\"#features-dynamicRenderingLocalRead\"><code>dynamicRenderingLocalRead</code></a> is not enabled, any variable created with a &#8220;Type&#8221; of <code>OpTypeImage</code> that has a &#8220;Dim&#8221; operand of <code>SubpassData</code> <strong class=\"purple\">must</strong> be decorated with <code>InputAttachmentIndex</code>",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-RuntimeSpirv-apiVersion-07954",
           "text": "If <a href=\"#VkPhysicalDeviceProperties\">VkPhysicalDeviceProperties</a>::<code>apiVersion</code> is less than Vulkan 1.3, the <a href=\"#VK_KHR_format_feature_flags2\">VK_KHR_format_feature_flags2</a> extension is not supported, and <a href=\"#features-shaderStorageImageWriteWithoutFormat\"><code>shaderStorageImageWriteWithoutFormat</code></a> is not enabled, any variable created with a &#8220;Type&#8221; of <code>OpTypeImage</code> that has a &#8220;Sampled&#8221; operand of 2 and an &#8220;Image Format&#8221; operand of <code>Unknown</code> <strong class=\"purple\">must</strong> be decorated with <code>NonWritable</code>",
           "page": "vkspec"
@@ -101696,6 +102171,36 @@
           "page": "vkspec"
         },
         {
+          "vuid": "VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat16-09559",
+          "text": "If <a href=\"#limits-shaderSignedZeroInfNanPreserveFloat16\"><code>shaderSignedZeroInfNanPreserveFloat16</code></a> is <code>VK_FALSE</code> then any <code>FPFastMathDefault</code> execution mode with a type of 16-bit float <strong class=\"purple\">must</strong> include the <code>NSZ</code>, <code>NotInf</code>, and <code>NotNaN</code> flags.",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat16-09560",
+          "text": "If <a href=\"#limits-shaderSignedZeroInfNanPreserveFloat16\"><code>shaderSignedZeroInfNanPreserveFloat16</code></a> is <code>VK_FALSE</code> then any <code>FPFastMath</code> decoration on an instruction with result type or any operand type that includes a 16-bit float <strong class=\"purple\">must</strong> include the <code>NSZ</code>, <code>NotInf</code>, and <code>NotNaN</code> flags.",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat32-09561",
+          "text": "If <a href=\"#limits-shaderSignedZeroInfNanPreserveFloat32\"><code>shaderSignedZeroInfNanPreserveFloat32</code></a> is <code>VK_FALSE</code> then any <code>FPFastMathDefault</code> execution mode with a type of 32-bit float <strong class=\"purple\">must</strong> include the <code>NSZ</code>, <code>NotInf</code>, and <code>NotNaN</code> flags.",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat32-09562",
+          "text": "If <a href=\"#limits-shaderSignedZeroInfNanPreserveFloat32\"><code>shaderSignedZeroInfNanPreserveFloat32</code></a> is <code>VK_FALSE</code> then any <code>FPFastMath</code> decoration on an instruction with result type or any operand type that includes a 32-bit float <strong class=\"purple\">must</strong> include the <code>NSZ</code>, <code>NotInf</code>, and <code>NotNaN</code> flags.",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat64-09563",
+          "text": "If <a href=\"#limits-shaderSignedZeroInfNanPreserveFloat64\"><code>shaderSignedZeroInfNanPreserveFloat64</code></a> is <code>VK_FALSE</code> then any <code>FPFastMathDefault</code> execution mode with a type of 64-bit float <strong class=\"purple\">must</strong> include the <code>NSZ</code>, <code>NotInf</code>, and <code>NotNaN</code> flags.",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat64-09564",
+          "text": "If <a href=\"#limits-shaderSignedZeroInfNanPreserveFloat64\"><code>shaderSignedZeroInfNanPreserveFloat64</code></a> is <code>VK_FALSE</code> then any <code>FPFastMath</code> decoration on an instruction with result type or any operand type that includes a 64-bit float <strong class=\"purple\">must</strong> include the <code>NSZ</code>, <code>NotInf</code>, and <code>NotNaN</code> flags.",
+          "page": "vkspec"
+        },
+        {
           "vuid": "VUID-RuntimeSpirv-Offset-06308",
           "text": "The <code>Offset</code> plus size of the type of each variable, in the output interface of the entry point being compiled, decorated with <code>XfbBuffer</code> <strong class=\"purple\">must</strong> not be greater than <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>::<code>maxTransformFeedbackBufferDataSize</code>",
           "page": "vkspec"
@@ -102602,7 +103107,17 @@
         },
         {
           "vuid": "VUID-RuntimeSpirv-pNext-09226",
-          "text": "If a <code>OpImageBlockMatchWindow*QCOM</code> operation is used, then <code>target</code> <code>sampled</code> <code>image</code> <strong class=\"purple\">must</strong> have been created using asampler object that included <a href=\"#VkSamplerBlockMatchWindowCreateInfoQCOM\">VkSamplerBlockMatchWindowCreateInfoQCOM</a> in the <code>pNext</code> chain.",
+          "text": "If a <code>OpImageBlockMatchWindow*QCOM</code> operation is used, then     <code>target</code> <code>sampled</code> <code>image</code> <strong class=\"purple\">must</strong> have been created using     asampler object that included     <a href=\"#VkSamplerBlockMatchWindowCreateInfoQCOM\">VkSamplerBlockMatchWindowCreateInfoQCOM</a> in the <code>pNext</code> chain. ifdef:VK_KHR_shader_maximal_reconvergence[]",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-RuntimeSpirv-MaximallyReconvergesKHR-09565",
+          "text": "The execution mode <code>MaximallyReconvergesKHR</code> <strong class=\"purple\">must</strong> not be applied to     an entry point unless the entry point does not execute any     <a href=\"#ray-tracing-repack\"><em>invocation repack instructions</em></a>. endif:VK_KHR_shader_maximal_reconvergence[]",
+          "page": "vkspec"
+        },
+        {
+          "vuid": "VUID-RuntimeSpirv-shaderSubgroupRotateClustered-09566",
+          "text": "If <a href=\"#features-shaderSubgroupRotateClustered\"><code>shaderSubgroupRotateClustered</code></a> is <code>VK_FALSE</code>, then the <code>ClusterSize</code> operand to <code>OpGroupNonUniformRotateKHR</code> <strong class=\"purple\">must</strong> not be used.",
           "page": "vkspec"
         }
       ]
diff --git a/registry/vk.xml b/registry/vk.xml
index fa39728..82ec5eb 100644..100755
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -175,7 +175,7 @@ branch of the member gitlab server.
 #define <name>VKSC_API_VERSION_1_0</name> <type>VK_MAKE_API_VERSION</type>(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0</type>
 
         <type api="vulkan" category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 275</type>
+#define <name>VK_HEADER_VERSION</name> 276</type>
         <type api="vulkan" category="define" requires="VK_HEADER_VERSION">// Complete version of this file
 #define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 3, VK_HEADER_VERSION)</type>
         <type api="vulkansc" category="define">// Version of this file
@@ -732,7 +732,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
         <type name="VkPerformanceOverrideTypeINTEL" category="enum"/>
         <type name="VkPerformanceParameterTypeINTEL" category="enum"/>
         <type name="VkPerformanceValueTypeINTEL" category="enum"/>
-        <type name="VkLineRasterizationModeEXT" category="enum"/>
+        <type name="VkLineRasterizationModeKHR" category="enum"/>
+        <type name="VkLineRasterizationModeEXT" category="enum" alias="VkLineRasterizationModeKHR"/>
         <type name="VkShaderModuleCreateFlagBits" category="enum"/>
         <type name="VkPipelineCompilerControlFlagBitsAMD" category="enum"/>
         <type name="VkShaderCorePropertiesFlagBitsAMD" category="enum"/>
@@ -3882,7 +3883,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member optional="true"><type>VkDebugUtilsMessengerCallbackDataFlagsEXT</type>                          <name>flags</name></member>
             <member optional="true" len="null-terminated">const <type>char</type>*                                  <name>pMessageIdName</name></member>
             <member><type>int32_t</type>                                                            <name>messageIdNumber</name></member>
-            <member len="null-terminated">const <type>char</type>*                                                  <name>pMessage</name></member>
+            <member optional="true" len="null-terminated">const <type>char</type>*                                  <name>pMessage</name></member>
             <member optional="true"><type>uint32_t</type>                                                           <name>queueLabelCount</name></member>
             <member len="queueLabelCount">const <type>VkDebugUtilsLabelEXT</type>*                  <name>pQueueLabels</name></member>
             <member optional="true"><type>uint32_t</type>                                                           <name>cmdBufLabelCount</name></member>
@@ -5016,7 +5017,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member optional="true"><type>void</type>*                               <name>pNext</name></member>
             <member limittype="bitmask"><type>VkShaderStageFlags</type>                  <name>cooperativeMatrixSupportedStages</name></member>
         </type>
-        <type category="struct" name="VkCooperativeMatrixPropertiesNV">
+        <type category="struct" name="VkCooperativeMatrixPropertiesNV" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*                               <name>pNext</name></member>
             <member><type>uint32_t</type>                            <name>MSize</name></member>
@@ -5231,11 +5232,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member><type>VkBool32</type>                            <name>shaderSubgroupClock</name></member>
             <member><type>VkBool32</type>                            <name>shaderDeviceClock</name></member>
         </type>
-        <type category="struct" name="VkPhysicalDeviceIndexTypeUint8FeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
-            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+        <type category="struct" name="VkPhysicalDeviceIndexTypeUint8FeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*        <name>pNext</name></member>
             <member><type>VkBool32</type>                           <name>indexTypeUint8</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceIndexTypeUint8FeaturesEXT"  alias="VkPhysicalDeviceIndexTypeUint8FeaturesKHR"/>
         <type category="struct" name="VkPhysicalDeviceShaderSMBuiltinsPropertiesNV" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*                          <name>pNext</name></member>
@@ -5401,8 +5403,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member><type>VkDeviceMemory</type>                   <name>memory</name></member>
         </type>
         <type category="struct" name="VkDeviceMemoryOpaqueCaptureAddressInfoKHR"               alias="VkDeviceMemoryOpaqueCaptureAddressInfo"/>
-        <type category="struct" name="VkPhysicalDeviceLineRasterizationFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
-            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+        <type category="struct" name="VkPhysicalDeviceLineRasterizationFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*        <name>pNext</name></member>
             <member><type>VkBool32</type>                           <name>rectangularLines</name></member>
             <member><type>VkBool32</type>                           <name>bresenhamLines</name></member>
@@ -5411,19 +5413,22 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member><type>VkBool32</type>                           <name>stippledBresenhamLines</name></member>
             <member><type>VkBool32</type>                           <name>stippledSmoothLines</name></member>
         </type>
-        <type category="struct" name="VkPhysicalDeviceLineRasterizationPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
-            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+        <type category="struct" name="VkPhysicalDeviceLineRasterizationFeaturesEXT" alias="VkPhysicalDeviceLineRasterizationFeaturesKHR"/>
+        <type category="struct" name="VkPhysicalDeviceLineRasterizationPropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*                               <name>pNext</name></member>
             <member limittype="bits"><type>uint32_t</type>                            <name>lineSubPixelPrecisionBits</name></member>
         </type>
-        <type category="struct" name="VkPipelineRasterizationLineStateCreateInfoEXT" structextends="VkPipelineRasterizationStateCreateInfo">
-            <member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
-            <member optional="true">const <type>void</type>*                                                      <name>pNext</name></member>
-            <member><type>VkLineRasterizationModeEXT</type>                                       <name>lineRasterizationMode</name></member>
+        <type category="struct" name="VkPhysicalDeviceLineRasterizationPropertiesEXT" alias="VkPhysicalDeviceLineRasterizationPropertiesKHR"/>
+        <type category="struct" name="VkPipelineRasterizationLineStateCreateInfoKHR" structextends="VkPipelineRasterizationStateCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true">const <type>void</type>*                                      <name>pNext</name></member>
+            <member><type>VkLineRasterizationModeKHR</type>                                       <name>lineRasterizationMode</name></member>
             <member><type>VkBool32</type>                                                         <name>stippledLineEnable</name></member>
             <member><type>uint32_t</type>                                                         <name>lineStippleFactor</name></member>
             <member><type>uint16_t</type>                                                         <name>lineStipplePattern</name></member>
         </type>
+        <type category="struct" name="VkPipelineRasterizationLineStateCreateInfoEXT" alias="VkPipelineRasterizationLineStateCreateInfoKHR"/>
         <type category="struct" name="VkPhysicalDevicePipelineCreationCacheControlFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>* <name>pNext</name></member>
@@ -6227,7 +6232,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member noautovalidity="true"><type>VkFragmentShadingRateNV</type>            <name>shadingRate</name></member>
             <member noautovalidity="true"><type>VkFragmentShadingRateCombinerOpKHR</type> <name>combinerOps</name>[2]</member>
         </type>
-        <type category="struct" name="VkAccelerationStructureBuildSizesInfoKHR">
+        <type category="struct" name="VkAccelerationStructureBuildSizesInfoKHR" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true">const <type>void</type>*        <name>pNext</name></member>
             <member><type>VkDeviceSize</type>                       <name>accelerationStructureSize</name></member>
@@ -7601,7 +7606,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member optional="true">const <type>void</type>*      <name>pNext</name></member>
             <member><type>zx_handle_t</type>                      <name>collectionToken</name></member>
         </type>
-        <type category="struct" name="VkBufferCollectionPropertiesFUCHSIA">
+        <type category="struct" name="VkBufferCollectionPropertiesFUCHSIA" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*            <name>pNext</name></member>
             <member><type>uint32_t</type>                         <name>memoryTypeBits</name></member>
@@ -8084,7 +8089,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
 
             <member optional="true"><type>VkMicromapEXT</type>                          <name>micromap</name></member>
         </type>
-        <type category="struct" name="VkPipelinePropertiesIdentifierEXT">
+        <type category="struct" name="VkPipelinePropertiesIdentifierEXT" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*              <name>pNext</name></member>
             <member><type>uint8_t</type>                            <name>pipelineIdentifier</name>[<enum>VK_UUID_SIZE</enum>]</member>
@@ -8347,7 +8352,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member optional="true"><type>uint32_t</type>                            <name>vendorInfoCount</name></member>
             <member optional="true"><type>VkDeviceSize</type>                        <name>vendorBinarySize</name><comment>Specified in bytes</comment></member>
         </type>
-        <type category="struct" name="VkDeviceFaultInfoEXT">
+        <type category="struct" name="VkDeviceFaultInfoEXT" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*               <name>pNext</name></member>
             <member noautovalidity="true"><type>char</type>          <name>description</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]<comment>Free-form description of the fault</comment></member>
@@ -8663,7 +8668,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member><type>VkBool32</type>                            <name>cooperativeMatrix</name></member>
             <member><type>VkBool32</type>                            <name>cooperativeMatrixRobustBufferAccess</name></member>
         </type>
-        <type category="struct" name="VkCooperativeMatrixPropertiesKHR">
+        <type category="struct" name="VkCooperativeMatrixPropertiesKHR" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*                               <name>pNext</name></member>
             <member><type>uint32_t</type>                            <name>MSize</name></member>
@@ -8990,6 +8995,51 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member><type>uint32_t</type>                                                    <name>stripeSemaphoreInfoCount</name></member>
             <member len="stripeSemaphoreInfoCount">const <type>VkSemaphoreSubmitInfo</type>* <name>pStripeSemaphoreInfos</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true"><type>void</type>*    <name>pNext</name></member>
+            <member><type>VkBool32</type> <name>shaderMaximalReconvergence</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true"><type>void</type>*    <name>pNext</name></member>
+            <member><type>VkBool32</type> <name>shaderSubgroupRotate</name></member>
+            <member><type>VkBool32</type> <name>shaderSubgroupRotateClustered</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceShaderExpectAssumeFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true" noautovalidity="true"><type>void</type>*     <name>pNext</name></member>
+            <member><type>VkBool32</type>                                        <name>shaderExpectAssume</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceShaderFloatControls2FeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+          <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+          <member optional="true"><type>void</type>*        <name>pNext</name></member>
+          <member><type>VkBool32</type>                     <name>shaderFloatControls2</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true" noautovalidity="true"><type>void</type>*                                <name>pNext</name></member>
+            <member><type>VkBool32</type>                                                                   <name>dynamicRenderingLocalRead</name></member>
+        </type>
+        <type category="struct" name="VkRenderingAttachmentLocationInfoKHR" structextends="VkGraphicsPipelineCreateInfo,VkCommandBufferInheritanceInfo">
+            <member values="VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true">const <type>void</type>*                                                <name>pNext</name></member>
+            <member optional="true"><type>uint32_t</type>                                                   <name>colorAttachmentCount</name></member>
+            <member noautovalidity="true" len="colorAttachmentCount">const <type>uint32_t</type>*           <name>pColorAttachmentLocations</name></member>
+        </type>
+        <type category="struct" name="VkRenderingInputAttachmentIndexInfoKHR" structextends="VkGraphicsPipelineCreateInfo,VkCommandBufferInheritanceInfo">
+            <member values="VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true">const <type>void</type>*                                                <name>pNext</name></member>
+            <member optional="true"><type>uint32_t</type>                                                   <name>colorAttachmentCount</name></member>
+            <member len="colorAttachmentCount" optional="true">const <type>uint32_t</type>*                 <name>pColorAttachmentInputIndices</name></member>
+            <member optional="true">const <type>uint32_t</type>*                                            <name>pDepthInputAttachmentIndex</name></member>
+            <member optional="true">const <type>uint32_t</type>*                                            <name>pStencilInputAttachmentIndex</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceShaderQuadControlFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true" noautovalidity="true"><type>void</type>*        <name>pNext</name></member>
+            <member><type>VkBool32</type>                           <name>shaderQuadControl</name></member>
+        </type>
     </types>
 
 
@@ -10414,11 +10464,15 @@ typedef void* <name>MTLSharedEvent_id</name>;
         <enum value="2" name="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR"/>
         <enum value="3" name="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR"/>
     </enums>
-    <enums name="VkLineRasterizationModeEXT" type="enum">
-        <enum value="0"     name="VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT"/>
-        <enum value="1"     name="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT"/>
-        <enum value="2"     name="VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT"/>
-        <enum value="3"     name="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT"/>
+    <enums name="VkLineRasterizationModeKHR" type="enum">
+        <enum value="0"     name="VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR"/>
+        <enum               name="VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT"             alias="VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR"/>
+        <enum value="1"     name="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR"/>
+        <enum               name="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT"         alias="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR"/>
+        <enum value="2"     name="VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR"/>
+        <enum               name="VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT"           alias="VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR"/>
+        <enum value="3"     name="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR"/>
+        <enum               name="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT"  alias="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR"/>
     </enums>
     <enums name="VkShaderModuleCreateFlagBits" type="bitmask">
     </enums>
@@ -13964,11 +14018,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <param optional="true" len="pInternalRepresentationCount"><type>VkPipelineExecutableInternalRepresentationKHR</type>* <name>pInternalRepresentations</name></param>
         </command>
         <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary" tasks="state">
-            <proto><type>void</type> <name>vkCmdSetLineStippleEXT</name></proto>
+            <proto><type>void</type> <name>vkCmdSetLineStippleKHR</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
             <param><type>uint32_t</type> <name>lineStippleFactor</name></param>
             <param><type>uint16_t</type> <name>lineStipplePattern</name></param>
         </command>
+        <command name="vkCmdSetLineStippleEXT" alias="vkCmdSetLineStippleKHR"/>
         <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkGetFaultData</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
@@ -15097,7 +15152,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
         <command>
             <proto><type>void</type> <name>vkDestroyShaderEXT</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
-            <param externsync="true"><type>VkShaderEXT</type> <name>shader</name></param>
+            <param optional="true" externsync="true"><type>VkShaderEXT</type> <name>shader</name></param>
             <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
         </command>
         <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
@@ -15230,6 +15285,16 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <param><type>VkQueue</type> <name>queue</name></param>
             <param>const <type>VkOutOfBandQueueTypeInfoNV</type>* <name>pQueueTypeInfo</name></param>
         </command>
+        <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary" tasks="state">
+            <proto><type>void</type> <name>vkCmdSetRenderingAttachmentLocationsKHR</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param>const <type>VkRenderingAttachmentLocationInfoKHR</type>* <name>pLocationInfo</name></param>
+        </command>
+        <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary" tasks="state">
+            <proto><type>void</type> <name>vkCmdSetRenderingInputAttachmentIndicesKHR</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param>const <type>VkRenderingInputAttachmentIndexInfoKHR</type>* <name>pLocationInfo</name></param>
+        </command>
     </commands>
 
     <feature api="vulkan,vulkansc" name="VK_VERSION_1_0" number="1.0" comment="Vulkan core API interface definitions">
@@ -20026,10 +20091,19 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_AMD_extension_232&quot;"              name="VK_AMD_EXTENSION_232_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_AMD_extension_233" number="233" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
+        <extension name="VK_KHR_dynamic_rendering_local_read" number="233" type="device" depends="VK_KHR_dynamic_rendering" author="AMD" contact="Tobias Hector @tobski" supported="vulkan" ratified="vulkan">
             <require>
-                <enum value="0"                                             name="VK_AMD_EXTENSION_233_SPEC_VERSION"/>
-                <enum value="&quot;VK_AMD_extension_233&quot;"              name="VK_AMD_EXTENSION_233_EXTENSION_NAME"/>
+                <enum value="1"                                             name="VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_dynamic_rendering_local_read&quot;" name="VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkImageLayout"                    name="VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR"/>
+                <command name="vkCmdSetRenderingAttachmentLocationsKHR"/>
+                <command name="vkCmdSetRenderingInputAttachmentIndicesKHR"/>
+                <type name="VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR"/>
+                <type name="VkRenderingAttachmentLocationInfoKHR"/>
+                <type name="VkRenderingInputAttachmentIndexInfoKHR"/>
+                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR"/>
+                <enum offset="1" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR"/>
+                <enum offset="2" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR"/>
             </require>
         </extension>
         <extension name="VK_AMD_extension_234" number="234" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
@@ -20046,10 +20120,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <type name="VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT"/>
             </require>
         </extension>
-        <extension name="VK_AMD_extension_236" number="236" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
+        <extension name="VK_KHR_shader_quad_control" number="236" type="device" depends="VK_VERSION_1_1+VK_KHR_vulkan_memory_model+VK_KHR_shader_maximal_reconvergence" author="KHR" contact="Tobias Hector @tobski" supported="vulkan" ratified="vulkan">
             <require>
-                <enum value="0"                                             name="VK_AMD_EXTENSION_236_SPEC_VERSION"/>
-                <enum value="&quot;VK_AMD_extension_236&quot;"              name="VK_AMD_EXTENSION_236_EXTENSION_NAME"/>
+                <enum value="1"                                             name="VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_shader_quad_control&quot;"          name="VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME"/>
+                <type                                                       name="VkPhysicalDeviceShaderQuadControlFeaturesKHR"/>
+                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR"/>
             </require>
         </extension>
         <extension name="VK_KHR_spirv_1_4" number="237" type="device" depends="VK_VERSION_1_1+VK_KHR_shader_float_controls" author="KHR" contact="Jesse Hall @critsec" supported="vulkan" promotedto="VK_VERSION_1_2" ratified="vulkan">
@@ -20342,10 +20418,10 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <require>
                 <enum value="1"                                             name="VK_EXT_LINE_RASTERIZATION_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_line_rasterization&quot;"         name="VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME"/>
-                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"/>
-                <enum offset="1" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"/>
-                <enum offset="2" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"/>
-                <enum offset="0" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_LINE_STIPPLE_EXT"/>
+                <enum extends="VkStructureType"                             name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR"/>
+                <enum extends="VkStructureType"                             name="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT" alias="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR"/>
+                <enum extends="VkStructureType"                             name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR"/>
+                <enum extends="VkDynamicState"                              name="VK_DYNAMIC_STATE_LINE_STIPPLE_EXT" alias="VK_DYNAMIC_STATE_LINE_STIPPLE_KHR"/>
                 <type name="VkPhysicalDeviceLineRasterizationFeaturesEXT"/>
                 <type name="VkPhysicalDeviceLineRasterizationPropertiesEXT"/>
                 <type name="VkPipelineRasterizationLineStateCreateInfoEXT"/>
@@ -20388,12 +20464,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_BRCM_extension_265&quot;"             name="VK_BRCM_EXTENSION_265_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_EXT_index_type_uint8" number="266" type="device" author="EXT" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Piers Daniell @pdaniell-nv" supported="vulkan,vulkansc">
+        <extension name="VK_EXT_index_type_uint8" number="266" type="device" author="EXT" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Piers Daniell @pdaniell-nv" supported="vulkan,vulkansc" promotedto="VK_KHR_index_type_uint8">
             <require>
                 <enum value="1"                                             name="VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_index_type_uint8&quot;"           name="VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME"/>
-                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"/>
-                <enum offset="0" extends="VkIndexType"                      name="VK_INDEX_TYPE_UINT8_EXT"/>
+                <enum extends="VkStructureType"                             name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR"/>
+                <enum extends="VkIndexType"                                 name="VK_INDEX_TYPE_UINT8_EXT" alias="VK_INDEX_TYPE_UINT8_KHR"/>
                 <type name="VkPhysicalDeviceIndexTypeUint8FeaturesEXT"/>
             </require>
         </extension>
@@ -22264,11 +22340,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_JUICE_extension_400&quot;"        name="VK_JUICE_EXTENSION_400_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_EXT_load_store_op_none" number="401" author="EXT" type="device" contact="Shahbaz Youssefi @syoussefi" supported="vulkan">
+        <extension name="VK_EXT_load_store_op_none" number="401" author="EXT" type="device" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" promotedto="VK_KHR_load_store_op_none" ratified="vulkan">
             <require>
                 <enum value="1"                                         name="VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION"/>
-                <enum value="&quot;VK_EXT_load_store_op_none&quot;"          name="VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME"/>
-                <enum offset="0" extends="VkAttachmentLoadOp" name="VK_ATTACHMENT_LOAD_OP_NONE_EXT"/>
+                <enum value="&quot;VK_EXT_load_store_op_none&quot;"     name="VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME"/>
+                <enum extends="VkAttachmentLoadOp" name="VK_ATTACHMENT_LOAD_OP_NONE_EXT" alias="VK_ATTACHMENT_LOAD_OP_NONE_KHR"/>
                 <enum extends="VkAttachmentStoreOp" name="VK_ATTACHMENT_STORE_OP_NONE_EXT" alias="VK_ATTACHMENT_STORE_OP_NONE"/>
             </require>
         </extension>
@@ -22394,10 +22470,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <type name="VkPhysicalDeviceShaderCorePropertiesARM"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_417" number="417" author="KHR" contact="Kevin Petit @kpet" supported="disabled">
+        <extension name="VK_KHR_shader_subgroup_rotate" number="417" author="KHR" contact="Kevin Petit @kpet" type="device" supported="vulkan" ratified="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_417_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_417&quot;"          name="VK_KHR_EXTENSION_417_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_shader_subgroup_rotate&quot;" name="VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR"/>
+                <type name="VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR"/>
             </require>
         </extension>
         <extension name="VK_ARM_scheduling_controls" number="418" author="ARM" contact="Kevin Petit @kpet" type="device" depends="VK_ARM_shader_core_builtins" supported="vulkan">
@@ -22581,10 +22659,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_GOOGLE_surfaceless_query&quot;"   name="VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_435" number="435" author="KHR" contact="Alan Baker @alan-baker" supported="disabled">
+        <extension name="VK_KHR_shader_maximal_reconvergence" number="435" type="device" author="KHR" depends="VK_VERSION_1_1" contact="Alan Baker @alan-baker" supported="vulkan" ratified="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_435_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_435&quot;"          name="VK_KHR_EXTENSION_435_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_shader_maximal_reconvergence&quot;"          name="VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR"/>
+                <type name="VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR"/>
             </require>
         </extension>
         <extension name="VK_EXT_application_parameters" number="436" type="instance" author="EXT" contact="Daniel Koch @dgkoch" supported="vulkansc">
@@ -22751,7 +22831,6 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_EXT_extended_dynamic_state3&quot;"     name="VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT"/>
                 <enum offset="1" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT"/>
-                <enum offset="2" extends="VkDynamicState"                    name="VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT"/>
                 <enum offset="3" extends="VkDynamicState"                    name="VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT"/>
                 <enum offset="4" extends="VkDynamicState"                    name="VK_DYNAMIC_STATE_POLYGON_MODE_EXT"/>
                 <enum offset="5" extends="VkDynamicState"                    name="VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT"/>
@@ -22762,21 +22841,10 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum offset="10" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT"/>
                 <enum offset="11" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT"/>
                 <enum offset="12" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT"/>
-                <enum offset="13" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT"/>
-                <enum offset="14" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT"/>
-                <enum offset="15" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT"/>
-                <enum offset="16" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT"/>
-                <enum offset="17" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT"/>
-                <enum offset="18" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT"/>
-                <enum offset="19" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT"/>
-                <enum offset="20" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT"/>
-                <enum offset="21" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT"/>
-                <enum offset="22" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT"/>
                 <type name="VkPhysicalDeviceExtendedDynamicState3FeaturesEXT"/>
                 <type name="VkPhysicalDeviceExtendedDynamicState3PropertiesEXT"/>
                 <type name="VkColorBlendEquationEXT"/>
                 <type name="VkColorBlendAdvancedEXT"/>
-                <command name="vkCmdSetTessellationDomainOriginEXT"/>
                 <command name="vkCmdSetDepthClampEnableEXT"/>
                 <command name="vkCmdSetPolygonModeEXT"/>
                 <command name="vkCmdSetRasterizationSamplesEXT"/>
@@ -22787,15 +22855,45 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <command name="vkCmdSetColorBlendEnableEXT"/>
                 <command name="vkCmdSetColorBlendEquationEXT"/>
                 <command name="vkCmdSetColorWriteMaskEXT"/>
+            </require>
+            <require depends="VK_KHR_maintenance2,VK_VERSION_1_1">
+                <enum offset="2" extends="VkDynamicState"                    name="VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT"/>
+                <command name="vkCmdSetTessellationDomainOriginEXT"/>
+            </require>
+            <require depends="VK_EXT_transform_feedback">
+                <enum offset="13" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT"/>
                 <command name="vkCmdSetRasterizationStreamEXT"/>
+            </require>
+            <require depends="VK_EXT_conservative_rasterization">
+                <enum offset="14" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT"/>
+                <enum offset="15" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT"/>
                 <command name="vkCmdSetConservativeRasterizationModeEXT"/>
                 <command name="vkCmdSetExtraPrimitiveOverestimationSizeEXT"/>
+            </require>
+            <require depends="VK_EXT_depth_clip_enable">
+                <enum offset="16" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT"/>
                 <command name="vkCmdSetDepthClipEnableEXT"/>
+            </require>
+            <require depends="VK_EXT_sample_locations">
+                <enum offset="17" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT"/>
                 <command name="vkCmdSetSampleLocationsEnableEXT"/>
+            </require>
+            <require depends="VK_EXT_blend_operation_advanced">
+                <enum offset="18" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT"/>
                 <command name="vkCmdSetColorBlendAdvancedEXT"/>
+            </require>
+            <require depends="VK_EXT_provoking_vertex">
+                <enum offset="19" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT"/>
                 <command name="vkCmdSetProvokingVertexModeEXT"/>
+            </require>
+            <require depends="VK_EXT_line_rasterization">
+                <enum offset="20" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT"/>
+                <enum offset="21" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT"/>
                 <command name="vkCmdSetLineRasterizationModeEXT"/>
                 <command name="vkCmdSetLineStippleEnableEXT"/>
+            </require>
+            <require depends="VK_EXT_depth_clip_control">
+                <enum offset="22" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT"/>
                 <command name="vkCmdSetDepthClipNegativeOneToOneEXT"/>
             </require>
             <require depends="VK_NV_clip_space_w_scaling">
@@ -23277,15 +23375,31 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <command name="vkCmdSetColorBlendEnableEXT"/>
                 <command name="vkCmdSetColorBlendEquationEXT"/>
                 <command name="vkCmdSetColorWriteMaskEXT"/>
+            </require>
+            <require depends="VK_EXT_transform_feedback">
                 <command name="vkCmdSetRasterizationStreamEXT"/>
+            </require>
+            <require depends="VK_EXT_conservative_rasterization">
                 <command name="vkCmdSetConservativeRasterizationModeEXT"/>
                 <command name="vkCmdSetExtraPrimitiveOverestimationSizeEXT"/>
+            </require>
+            <require depends="VK_EXT_depth_clip_enable">
                 <command name="vkCmdSetDepthClipEnableEXT"/>
+            </require>
+            <require depends="VK_EXT_sample_locations">
                 <command name="vkCmdSetSampleLocationsEnableEXT"/>
+            </require>
+            <require depends="VK_EXT_blend_operation_advanced">
                 <command name="vkCmdSetColorBlendAdvancedEXT"/>
+            </require>
+            <require depends="VK_EXT_provoking_vertex">
                 <command name="vkCmdSetProvokingVertexModeEXT"/>
+            </require>
+            <require depends="VK_EXT_line_rasterization">
                 <command name="vkCmdSetLineRasterizationModeEXT"/>
                 <command name="vkCmdSetLineStippleEnableEXT"/>
+            </require>
+            <require depends="VK_EXT_depth_clip_control">
                 <command name="vkCmdSetDepthClipNegativeOneToOneEXT"/>
             </require>
             <require depends="VK_EXT_subgroup_size_control,VK_VERSION_1_3">
@@ -23750,10 +23864,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <type name="VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR"/>
             </require>
         </extension>
-        <extension name="VK_EXT_extension_527" number="527" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
+        <extension name="VK_KHR_load_store_op_none" number="527" author="KHR" type="device" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" ratified="vulkan">
             <require>
-                <enum value="0"                                         name="VK_EXT_EXTENSION_527_SPEC_VERSION"/>
-                <enum value="&quot;VK_EXT_extension_527&quot;"          name="VK_EXT_EXTENSION_527_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_load_store_op_none&quot;"     name="VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkAttachmentLoadOp" extnumber="401" name="VK_ATTACHMENT_LOAD_OP_NONE_KHR"/>
+                <enum extends="VkAttachmentStoreOp" name="VK_ATTACHMENT_STORE_OP_NONE_KHR" alias="VK_ATTACHMENT_STORE_OP_NONE"/>
             </require>
         </extension>
         <extension name="VK_EXT_extension_528" number="528" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
@@ -23762,10 +23878,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_EXT_extension_528&quot;"          name="VK_EXT_EXTENSION_528_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_529" number="529" author="KHR" contact="Graeme Leese @gnl21" supported="disabled">
+        <extension name="VK_KHR_shader_float_controls2" number="529" type="device" depends="VK_VERSION_1_1+VK_KHR_shader_float_controls" author="KHR" contact="Graeme Leese @gnl21" supported="vulkan" ratified="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_529_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_529&quot;"          name="VK_KHR_EXTENSION_529_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_shader_float_controls2&quot;" name="VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME"/>
+                <type name="VkPhysicalDeviceShaderFloatControls2FeaturesKHR"/>
+                <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR"/>
             </require>
         </extension>
         <extension name="VK_QNX_external_memory_screen_buffer" number="530" type="device" author="QNX" depends="((VK_KHR_sampler_ycbcr_conversion+VK_KHR_external_memory+VK_KHR_dedicated_allocation),VK_VERSION_1_1)+VK_EXT_queue_family_foreign" platform="screen" contact="Mike Gorchak @mgorchak-blackberry, Aaron Ruby @aruby-blackberry" supported="vulkan,vulkansc">
@@ -23807,16 +23925,28 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_EXT_extension_533&quot;"          name="VK_EXT_EXTENSION_533_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_534" number="534" author="KHR" contact="Piers Daniell @pdaniell-nv" supported="disabled">
+        <extension name="VK_KHR_index_type_uint8" number="534" type="device" author="KHR" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Piers Daniell @pdaniell-nv" supported="vulkan" ratified="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_534_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_534&quot;"          name="VK_KHR_EXTENSION_534_EXTENSION_NAME"/>
+                <enum value="1"                                             name="VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_index_type_uint8&quot;"           name="VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType" extnumber="266"  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR"/>
+                <enum offset="0" extends="VkIndexType" extnumber="266"      name="VK_INDEX_TYPE_UINT8_KHR"/>
+                <type name="VkPhysicalDeviceIndexTypeUint8FeaturesKHR"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_535" number="535" author="KHR" contact="Piers Daniell @pdaniell-nv" supported="disabled">
+        <extension name="VK_KHR_line_rasterization" number="535" type="device" author="KHR" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Piers Daniell @pdaniell-nv" supported="vulkan" ratified="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_535_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_535&quot;"          name="VK_KHR_EXTENSION_535_EXTENSION_NAME"/>
+                <enum value="1"                                             name="VK_KHR_LINE_RASTERIZATION_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_line_rasterization&quot;"         name="VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType" extnumber="260"  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR"/>
+                <enum offset="1" extends="VkStructureType" extnumber="260"  name="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR"/>
+                <enum offset="2" extends="VkStructureType" extnumber="260"  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR"/>
+                <enum offset="0" extends="VkDynamicState"  extnumber="260"  name="VK_DYNAMIC_STATE_LINE_STIPPLE_KHR"/>
+                <type name="VkPhysicalDeviceLineRasterizationFeaturesKHR"/>
+                <type name="VkPhysicalDeviceLineRasterizationPropertiesKHR"/>
+                <type name="VkPipelineRasterizationLineStateCreateInfoKHR"/>
+                <type name="VkLineRasterizationModeKHR"/>
+                <command name="vkCmdSetLineStippleKHR"/>
             </require>
         </extension>
         <extension name="VK_QCOM_extension_536" number="536" type="device" author="QCOM" contact="Matthew Netsch @mnetsch" supported="disabled">
@@ -23878,10 +24008,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <command name="vkGetCalibratedTimestampsKHR"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_545" number="545" author="KHR" contact="Kevin Petit @kpet" supported="disabled">
+        <extension name="VK_KHR_shader_expect_assume" number="545" type="device" author="KHR" depends="VK_KHR_get_physical_device_properties2" contact="Kevin Petit @kpet" supported="vulkan" ratified="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_545_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_545&quot;"          name="VK_KHR_EXTENSION_545_EXTENSION_NAME"/>
+                <enum value="1"                                             name="VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_shader_expect_assume&quot;"       name="VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR"/>
+                <type name="VkPhysicalDeviceShaderExpectAssumeFeaturesKHR"/>
             </require>
         </extension>
         <extension name="VK_KHR_maintenance6" number="546" type="device" depends="VK_VERSION_1_1" author="KHR" contact="Jon Leech @oddhack" supported="vulkan" ratified="vulkan">
@@ -23984,6 +24116,24 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_NV_extension_556&quot;"               name="VK_NV_EXTENSION_556_EXTENSION_NAME"/>
             </require>
         </extension>
+        <extension name="VK_NV_extension_557" number="557" type="device" author="NV" contact="Chris Lentini @clentini" supported="disabled">
+            <require>
+                <enum value="1"                                             name="VK_NV_EXTENSION_557_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_extension_557&quot;"               name="VK_NV_EXTENSION_557_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_KHR_extension_558" number="558" type="device" author="KHR" contact="Ahmed Abdelkhalek @aabdelkh" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_KHR_EXTENSION_558_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_extension_558&quot;"              name="VK_KHR_EXTENSION_558_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_KHR_extension_559" number="559" type="device" author="KHR" contact="Nathan Gauër @Keenuts1" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_KHR_EXTENSION_559_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_extension_559&quot;"              name="VK_KHR_EXTENSION_559_EXTENSION_NAME"/>
+            </require>
+        </extension>
     </extensions>
     <formats>
         <format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">
@@ -25612,6 +25762,21 @@ typedef void* <name>MTLSharedEvent_id</name>;
         <spirvextension name="SPV_NV_ray_tracing_motion_blur">
             <enable extension="VK_NV_ray_tracing_motion_blur"/>
         </spirvextension>
+        <spirvextension name="SPV_KHR_maximal_reconvergence">
+            <enable extension="VK_KHR_shader_maximal_reconvergence"/>
+        </spirvextension>
+        <spirvextension name="SPV_KHR_subgroup_rotate">
+            <enable extension="VK_KHR_shader_subgroup_rotate"/>
+        </spirvextension>
+        <spirvextension name="SPV_KHR_expect_assume">
+            <enable extension="VK_KHR_shader_expect_assume"/>
+        </spirvextension>
+        <spirvextension name="SPV_KHR_float_controls2">
+            <enable extension="VK_KHR_shader_float_controls2"/>
+        </spirvextension>
+        <spirvextension name="SPV_KHR_quad_control">
+            <enable extension="VK_KHR_shader_quad_control"/>
+        </spirvextension>
     </spirvextensions>
     <spirvcapabilities comment="SPIR-V Capabilities allowed in Vulkan and what is required to use it">
         <spirvcapability name="Matrix">
@@ -26107,6 +26272,18 @@ typedef void* <name>MTLSharedEvent_id</name>;
         <spirvcapability name="ShaderEnqueueAMDX">
             <enable struct="VkPhysicalDeviceShaderEnqueueFeaturesAMDX" feature="shaderEnqueue" requires="VK_AMDX_shader_enqueue"/>
         </spirvcapability>
+        <spirvcapability name="GroupNonUniformRotateKHR">
+            <enable struct="VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR" feature="shaderSubgroupRotate" requires="VK_KHR_shader_subgroup_rotate"/>
+        </spirvcapability>
+        <spirvcapability name="ExpectAssumeKHR">
+            <enable struct="VkPhysicalDeviceShaderExpectAssumeFeaturesKHR" feature="shaderExpectAssume" requires="VK_KHR_shader_expect_assume"/>
+        </spirvcapability>
+        <spirvcapability name="FloatControls2">
+            <enable struct="VkPhysicalDeviceShaderFloatControls2FeaturesKHR" feature="shaderFloatControls2" requires="VK_KHR_shader_float_controls2"/>
+        </spirvcapability>
+        <spirvcapability name="QuadControlKHR">
+            <enable struct="VkPhysicalDeviceShaderQuadControlFeaturesKHR" feature="shaderQuadControl" requires="VK_KHR_shader_quad_control"/>
+        </spirvcapability>
     </spirvcapabilities>
     <sync comment="Machine readable representation of the synchronization objects and their mappings">
         <syncstage name="VK_PIPELINE_STAGE_2_NONE" alias="VK_PIPELINE_STAGE_NONE">
author	Jon Leech <[email protected]>	2024-01-25 03:38:43 -0800
committer	Jon Leech <[email protected]>	2024-01-25 03:53:51 -0800
commit	170cde531f13bb367f6eaa6a392c0058a73bda03 (patch)
tree	a1bbe0693a0fa882428b3801376c0b9f0e585fb2
parent	217e93c664ec6704ec2d8c36fa116c1a4a1e2d40 (diff)
download	Vulkan-Headers-170cde531f13bb367f6eaa6a392c0058a73bda03.tar.gz Vulkan-Headers-170cde531f13bb367f6eaa6a392c0058a73bda03.zip