Update for Vulkan-Docs 1.4.332

include/vulkan/vulkan.cppm

@@ -18,11 +18,7 @@ module;
   "To silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n\n" \
   "For feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues"
 
-#  if defined( __clang__ ) || defined( __GNUC__ ) || defined( __GNUG__ )
+VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING )
-_Pragma( VULKAN_HPP_STRINGIFY( GCC warning VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) )
-#  elif defined( _MSC_VER )
-_Pragma( VULKAN_HPP_STRINGIFY( message( __FILE__ "(" VULKAN_HPP_STRINGIFY( __LINE__ ) "): warning: " VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) ) )
-#  endif
 #endif
 
 #include <vulkan/vulkan.hpp>
@@ -32,8 +28,8 @@ _Pragma( VULKAN_HPP_STRINGIFY( message( __FILE__ "(" VULKAN_HPP_STRINGIFY( __LIN
 #include <vulkan/vulkan_raii.hpp>
 #include <vulkan/vulkan_shared.hpp>
 
-  export module vulkan_hpp;
+export module vulkan_hpp;
-export import VULKAN_HPP_STD_MODULE;
+export import std.compat;
 
 export namespace VULKAN_HPP_NAMESPACE
 {
@@ -1052,6 +1048,9 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagBitsARM;
   using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsARM;
 
+  //=== VK_QCOM_data_graph_model ===
+  using VULKAN_HPP_NAMESPACE::DataGraphModelCacheTypeQCOM;
+
   //=== VK_KHR_maintenance10 ===
   using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagBitsKHR;
   using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsKHR;
@@ -2979,6 +2978,11 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::EXTShader64BitIndexingExtensionName;
   using VULKAN_HPP_NAMESPACE::EXTShader64BitIndexingSpecVersion;
 
+  //=== VK_QCOM_data_graph_model ===
+  using VULKAN_HPP_NAMESPACE::DataGraphModelToolchainVersionLengthQCOM;
+  using VULKAN_HPP_NAMESPACE::QCOMDataGraphModelExtensionName;
+  using VULKAN_HPP_NAMESPACE::QCOMDataGraphModelSpecVersion;
+
   //=== VK_KHR_maintenance10 ===
   using VULKAN_HPP_NAMESPACE::KHRMaintenance10ExtensionName;
   using VULKAN_HPP_NAMESPACE::KHRMaintenance10SpecVersion;
@@ -5278,6 +5282,11 @@ export namespace VULKAN_HPP_NAMESPACE
   //=== VK_EXT_shader_64bit_indexing ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT;
 
+  //=== VK_QCOM_data_graph_model ===
+  using VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM;
+  using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM;
+
   //=== VK_KHR_maintenance10 ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR;
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR;
@@ -9339,6 +9348,14 @@ export namespace std
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT>;
 
+  //=== VK_QCOM_data_graph_model ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>;
+
   //=== VK_KHR_maintenance10 ===
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR>;

include/vulkan/vulkan.hpp

@@ -38,7 +38,7 @@
 #  include <cassert>
 #  include <cstdlib>
 #  include <cstring>
-import VULKAN_HPP_STD_MODULE;
+import std.compat;
 #endif
 #include <vulkan/vulkan.h>
 
@@ -58,7 +58,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  endif
 #endif
 
-static_assert( VK_HEADER_VERSION == 331, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 332, "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)
@@ -7614,6 +7614,9 @@ namespace VULKAN_HPP_NAMESPACE
   //=== VK_NV_partitioned_acceleration_structure ===
   VULKAN_HPP_CONSTEXPR_INLINE uint32_t PartitionedAccelerationStructurePartitionIndexGlobalNV = VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV;
 
+  //=== VK_QCOM_data_graph_model ===
+  VULKAN_HPP_CONSTEXPR_INLINE uint32_t DataGraphModelToolchainVersionLengthQCOM = VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM;
+
   //========================
   //=== CONSTEXPR VALUEs ===
   //========================
@@ -9530,6 +9533,10 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingExtensionName = VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingSpecVersion   = VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION;
 
+  //=== VK_QCOM_data_graph_model ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelExtensionName = VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelSpecVersion   = VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION;
+
   //=== VK_KHR_maintenance10 ===
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10ExtensionName = VK_KHR_MAINTENANCE_10_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10SpecVersion   = VK_KHR_MAINTENANCE_10_SPEC_VERSION;
@@ -19702,6 +19709,34 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_QCOM_data_graph_model ===
+  template <>
+  struct StructExtends<DataGraphPipelineBuiltinModelCreateInfoQCOM, DataGraphPipelineCreateInfoARM>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceDataGraphModelFeaturesQCOM, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceDataGraphModelFeaturesQCOM, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_KHR_maintenance10 ===
   template <>
   struct StructExtends<PhysicalDeviceMaintenance10FeaturesKHR, PhysicalDeviceFeatures2>

include/vulkan/vulkan_core.h

@@ -66,7 +66,7 @@ extern "C" {
 //#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 331
+#define VK_HEADER_VERSION 332
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@@ -1358,6 +1358,8 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT = 1000620000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR = 1000361000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT = 1000627000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM = 1000629000,
+    VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM = 1000629001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR = 1000630000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR = 1000630001,
     VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR = 1000630002,
@@ -2182,6 +2184,7 @@ typedef enum VkIndexType {
 
 typedef enum VkPipelineCacheHeaderVersion {
     VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
+    VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM = 1000629000,
     VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
 } VkPipelineCacheHeaderVersion;
 
@@ -22228,11 +22231,15 @@ typedef enum VkDataGraphPipelinePropertyARM {
 
 typedef enum VkPhysicalDeviceDataGraphProcessingEngineTypeARM {
     VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM = 0,
+    VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM = 1000629000,
+    VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM = 1000629001,
     VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF
 } VkPhysicalDeviceDataGraphProcessingEngineTypeARM;
 
 typedef enum VkPhysicalDeviceDataGraphOperationTypeARM {
     VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM = 0,
+    VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM = 1000629000,
+    VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM = 1000629001,
     VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF
 } VkPhysicalDeviceDataGraphOperationTypeARM;
 typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagsARM;
@@ -23890,6 +23897,38 @@ typedef struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT {
 
 
 
+// VK_QCOM_data_graph_model is a preprocessor guard. Do not pass it to API calls.
+#define VK_QCOM_data_graph_model 1
+#define VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM 3U
+#define VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION 1
+#define VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME "VK_QCOM_data_graph_model"
+
+typedef enum VkDataGraphModelCacheTypeQCOM {
+    VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM = 0,
+    VK_DATA_GRAPH_MODEL_CACHE_TYPE_MAX_ENUM_QCOM = 0x7FFFFFFF
+} VkDataGraphModelCacheTypeQCOM;
+typedef struct VkPipelineCacheHeaderVersionDataGraphQCOM {
+    uint32_t                         headerSize;
+    VkPipelineCacheHeaderVersion     headerVersion;
+    VkDataGraphModelCacheTypeQCOM    cacheType;
+    uint32_t                         cacheVersion;
+    uint32_t                         toolchainVersion[VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM];
+} VkPipelineCacheHeaderVersionDataGraphQCOM;
+
+typedef struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM {
+    VkStructureType                                        sType;
+    const void*                                            pNext;
+    const VkPhysicalDeviceDataGraphOperationSupportARM*    pOperation;
+} VkDataGraphPipelineBuiltinModelCreateInfoQCOM;
+
+typedef struct VkPhysicalDeviceDataGraphModelFeaturesQCOM {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           dataGraphModel;
+} VkPhysicalDeviceDataGraphModelFeaturesQCOM;
+
+
+
 // VK_SEC_pipeline_cache_incremental_mode is a preprocessor guard. Do not pass it to API calls.
 #define VK_SEC_pipeline_cache_incremental_mode 1
 #define VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION 1

include/vulkan/vulkan_enums.hpp

@@ -1733,6 +1733,8 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR      = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR,
     ePhysicalDevicePresentModeFifoLatestReadyFeaturesEXT      = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT,
     ePhysicalDeviceShader64BitIndexingFeaturesEXT             = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT,
+    ePhysicalDeviceDataGraphModelFeaturesQCOM                 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM,
+    eDataGraphPipelineBuiltinModelCreateInfoQCOM              = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM,
     ePhysicalDeviceMaintenance10FeaturesKHR                   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR,
     ePhysicalDeviceMaintenance10PropertiesKHR                 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR,
     eRenderingAttachmentFlagsInfoKHR                          = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR,
@@ -3191,7 +3193,8 @@ namespace VULKAN_HPP_NAMESPACE
   // wrapper class for enum VkPipelineCacheHeaderVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersion.html
   enum class PipelineCacheHeaderVersion
   {
-    eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
+    eOne           = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
+    eDataGraphQCOM = VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM
   };
 
   // wrapper class for enum VkEventCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEventCreateFlagBits.html
@@ -8805,14 +8808,18 @@ namespace VULKAN_HPP_NAMESPACE
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphProcessingEngineTypeARM.html
   enum class PhysicalDeviceDataGraphProcessingEngineTypeARM
   {
-    eDefault = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM
+    eDefault     = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM,
+    eNeuralQCOM  = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM,
+    eComputeQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM
   };
 
   // wrapper class for enum VkPhysicalDeviceDataGraphOperationTypeARM, see
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationTypeARM.html
   enum class PhysicalDeviceDataGraphOperationTypeARM
   {
-    eSpirvExtendedInstructionSet = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM
+    eSpirvExtendedInstructionSet = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM,
+    eNeuralModelQCOM             = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM,
+    eBuiltinModelQCOM            = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM
   };
 
   //=== VK_KHR_video_encode_av1 ===
@@ -9405,6 +9412,14 @@ namespace VULKAN_HPP_NAMESPACE
     static VULKAN_HPP_CONST_OR_CONSTEXPR PerformanceCounterDescriptionFlagsARM allFlags  = {};
   };
 
+  //=== VK_QCOM_data_graph_model ===
+
+  // wrapper class for enum VkDataGraphModelCacheTypeQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphModelCacheTypeQCOM.html
+  enum class DataGraphModelCacheTypeQCOM
+  {
+    eGenericBinary = VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM
+  };
+
   //=== VK_KHR_maintenance10 ===
 
   // wrapper class for enum VkRenderingAttachmentFlagBitsKHR, see

include/vulkan/vulkan_extension_inspection.hpp

@@ -508,6 +508,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                             "VK_EXT_zero_initialize_device_memory",
                                                             "VK_KHR_present_mode_fifo_latest_ready",
                                                             "VK_EXT_shader_64bit_indexing",
+                                                            "VK_QCOM_data_graph_model",
                                                             "VK_KHR_maintenance10",
                                                             "VK_SEC_pipeline_cache_incremental_mode",
                                                             "VK_EXT_shader_uniform_buffer_unsized_array" };
@@ -1782,7 +1783,17 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_get_physical_device_properties2",
             } } },
-          { "VK_VERSION_1_1", { {} } } } },
+          { "VK_VERSION_1_1", { {} } } } }
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+      ,
+      { "VK_NV_cuda_kernel_launch",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } }
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      ,
       { "VK_QCOM_tile_shading",
         { { "VK_VERSION_1_0",
             { {
@@ -2059,6 +2070,12 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_frame_boundary",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_EXT_multisampled_render_to_single_sampled",
         { { "VK_VERSION_1_0",
             { {
@@ -2179,6 +2196,12 @@ namespace VULKAN_HPP_NAMESPACE
             } } } } },
       { "VK_KHR_maintenance4", { { "VK_VERSION_1_1", { {} } } } },
       { "VK_ARM_shader_core_properties", { { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_shader_subgroup_rotate",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_ARM_scheduling_controls",
         { { "VK_VERSION_1_0",
             { {
@@ -2382,7 +2405,13 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_dynamic_rendering",
             } } },
-          { "VK_VERSION_1_3", { {} } } } }
+          { "VK_VERSION_1_3", { {} } } } },
+      { "VK_AMD_anti_lag",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } }
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
       ,
       { "VK_AMDX_dense_geometry_format",
@@ -2476,6 +2505,18 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_ray_tracing_pipeline",
             } } } } },
+      { "VK_NV_cooperative_vector",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_extended_sparse_address_space",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_EXT_mutable_descriptor_type",
         { { "VK_VERSION_1_0",
             { {
@@ -2539,6 +2580,12 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_deferred_host_operations",
               "VK_KHR_maintenance5",
             } } } } },
+      { "VK_QCOM_multiview_per_view_render_areas",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_compute_shader_derivatives",
         { { "VK_VERSION_1_0",
             { {
@@ -2581,6 +2628,12 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_EXT_filter_cubic",
             } } } } },
+      { "VK_QCOM_ycbcr_degamma",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_QCOM_filter_cubic_clamp",
         { { "VK_VERSION_1_0",
             { {
@@ -2607,6 +2660,12 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_unified_image_layouts",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_shader_float_controls2",
         { { "VK_VERSION_1_1",
             { {
@@ -2701,7 +2760,49 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_video_encode_queue",
             } } } } },
+      { "VK_NV_raw_access_chains",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_shader_relaxed_extended_instruction",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_command_buffer_inheritance",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_shader_atomic_float16_vector",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_shader_replicated_composites",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_shader_float8",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_ray_tracing_validation",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_NV_cluster_acceleration_structure",
         { { "VK_VERSION_1_0",
             { {
@@ -2730,6 +2831,12 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_shader_fma",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_EXT_depth_clamp_control",
         { { "VK_VERSION_1_0",
             { {
@@ -2806,6 +2913,12 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_ARM_format_pack",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_VALVE_fragment_density_map_layered",
         { { "VK_VERSION_1_0",
             { {
@@ -2821,7 +2934,17 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_get_physical_device_properties2",
             } } },
-          { "VK_VERSION_1_1", { {} } } } },
+          { "VK_VERSION_1_1", { {} } } } }
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+      ,
+      { "VK_NV_present_metering",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } }
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      ,
       { "VK_EXT_fragment_density_map_offset",
         { { "VK_VERSION_1_0",
             { {
@@ -2862,7 +2985,24 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_QCOM_data_graph_model",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_ARM_data_graph",
+            } } } } },
       { "VK_KHR_maintenance10",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_SEC_pipeline_cache_incremental_mode",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_shader_uniform_buffer_unsized_array",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_get_physical_device_properties2",
@@ -3813,8 +3953,8 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
         || ( extension == "VK_EXT_fragment_density_map_offset" ) || ( extension == "VK_EXT_zero_initialize_device_memory" ) ||
            ( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_shader_64bit_indexing" ) ||
-           ( extension == "VK_KHR_maintenance10" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) ||
+           ( extension == "VK_QCOM_data_graph_model" ) || ( extension == "VK_KHR_maintenance10" ) ||
-           ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" );
+           ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) || ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" );
   }
 
   VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )

include/vulkan/vulkan_handles.hpp

@@ -2247,6 +2247,11 @@ namespace VULKAN_HPP_NAMESPACE
   //=== VK_EXT_shader_64bit_indexing ===
   struct PhysicalDeviceShader64BitIndexingFeaturesEXT;
 
+  //=== VK_QCOM_data_graph_model ===
+  struct PipelineCacheHeaderVersionDataGraphQCOM;
+  struct DataGraphPipelineBuiltinModelCreateInfoQCOM;
+  struct PhysicalDeviceDataGraphModelFeaturesQCOM;
+
   //=== VK_KHR_maintenance10 ===
   struct PhysicalDeviceMaintenance10FeaturesKHR;
   struct PhysicalDeviceMaintenance10PropertiesKHR;

include/vulkan/vulkan_hash.hpp

@@ -3442,6 +3442,37 @@ namespace std
   };
 #  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM const & physicalDeviceDataGraphOperationSupportARM ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.operationType );
+      for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM; ++i )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.name[i] );
+      }
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.version );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM const & dataGraphPipelineBuiltinModelCreateInfoQCOM ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pOperation );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM>
   {
@@ -9672,18 +9703,15 @@ namespace std
   };
 
   template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>
   {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM const & physicalDeviceDataGraphOperationSupportARM ) const
+    std::size_t
-      VULKAN_HPP_NOEXCEPT
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM const & physicalDeviceDataGraphModelFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
     {
       std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.operationType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.sType );
-      for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM; ++i )
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.pNext );
-      {
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.dataGraphModel );
-        VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.name[i] );
-      }
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.version );
       return seed;
     }
   };
@@ -15423,6 +15451,25 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM const & pipelineCacheHeaderVersionDataGraphQCOM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerSize );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerVersion );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheType );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheVersion );
+      for ( size_t i = 0; i < VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM; ++i )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.toolchainVersion[i] );
+      }
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>
   {

include/vulkan/vulkan_hpp_macros.hpp

@@ -35,6 +35,18 @@
 #  include <ciso646>
 #endif
 
+#define VULKAN_HPP_STRINGIFY2( text ) #text
+#define VULKAN_HPP_STRINGIFY( text )  VULKAN_HPP_STRINGIFY2( text )
+#define VULKAN_HPP_NAMESPACE_STRING   VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
+
+#if defined( __clang__ ) || defined( __GNUC__ ) || defined( __GNUG__ )
+#  define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( GCC warning text ) )
+#elif defined( _MSC_VER )
+#  define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( message( __FILE__ "(" VULKAN_HPP_STRINGIFY( __LINE__ ) "): warning: " text ) ) )
+#else
+#  define VULKAN_HPP_COMPILE_WARNING( text )
+#endif
+
 #if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
 #  if !defined( VULKAN_HPP_NO_SMART_HANDLE )
 #    define VULKAN_HPP_NO_SMART_HANDLE
@@ -87,8 +99,8 @@
 #  define VULKAN_HPP_SUPPORT_SPAN
 #endif
 
-#if !defined( VULKAN_HPP_STD_MODULE ) && defined( __cpp_modules ) && defined( __cpp_lib_modules )
+#if defined( VULKAN_HPP_CXX_MODULE ) && !( defined( __cpp_modules ) && defined( __cpp_lib_modules ) )
-#  define VULKAN_HPP_STD_MODULE std.compat
+VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ named modules and the standard library module." )
 #endif
 
 #ifndef VK_USE_64_BIT_PTR_DEFINES
@@ -225,10 +237,6 @@
 #  define VULKAN_HPP_NAMESPACE vk
 #endif
 
-#define VULKAN_HPP_STRINGIFY2( text ) #text
-#define VULKAN_HPP_STRINGIFY( text )  VULKAN_HPP_STRINGIFY2( text )
-#define VULKAN_HPP_NAMESPACE_STRING   VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
-
 #if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
 #  if defined( VK_NO_PROTOTYPES )
 #    define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1

include/vulkan/vulkan_ohos.h

@@ -22,7 +22,7 @@ extern "C" {
 // VK_OHOS_external_memory is a preprocessor guard. Do not pass it to API calls.
 #define VK_OHOS_external_memory 1
 struct OH_NativeBuffer;
-#define VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION 2
+#define VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION 1
 #define VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME "VK_OHOS_external_memory"
 typedef struct VkNativeBufferUsageOHOS {
     VkStructureType    sType;

include/vulkan/vulkan_static_assertions.hpp

@@ -9423,6 +9423,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::PhysicalDeviceShader64BitIndexingFeaturesEXT>::value,
                           "PhysicalDeviceShader64BitIndexingFeaturesEXT is not nothrow_move_constructible!" );
 
+//=== VK_QCOM_data_graph_model ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM ) == sizeof( VkPipelineCacheHeaderVersionDataGraphQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>::value,
+                          "PipelineCacheHeaderVersionDataGraphQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM ) ==
+                            sizeof( VkDataGraphPipelineBuiltinModelCreateInfoQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>::value,
+                          "DataGraphPipelineBuiltinModelCreateInfoQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM ) == sizeof( VkPhysicalDeviceDataGraphModelFeaturesQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>::value,
+                          "PhysicalDeviceDataGraphModelFeaturesQCOM is not nothrow_move_constructible!" );
+
 //=== VK_KHR_maintenance10 ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance10FeaturesKHR ),

include/vulkan/vulkan_structs.hpp

@@ -28354,6 +28354,269 @@ namespace VULKAN_HPP_NAMESPACE
   };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
+  // wrapper struct for struct VkPhysicalDeviceDataGraphOperationSupportARM, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationSupportARM.html
+  struct PhysicalDeviceDataGraphOperationSupportARM
+  {
+    using NativeType = VkPhysicalDeviceDataGraphOperationSupportARM;
+
+#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM(
+      PhysicalDeviceDataGraphOperationTypeARM operationType_ = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet,
+      std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const & name_    = {},
+      uint32_t                                                                                version_ = {} ) VULKAN_HPP_NOEXCEPT
+      : operationType{ operationType_ }
+      , name{ name_ }
+      , version{ version_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceDataGraphOperationSupportARM( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceDataGraphOperationSupportARM( *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs ) )
+    {
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationTypeARM operationType_, std::string const & name_, uint32_t version_ = {} )
+      : operationType( operationType_ ), version( version_ )
+    {
+      VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
+#    if defined( _WIN32 )
+      strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
+#    else
+      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
+#    endif
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    PhysicalDeviceDataGraphOperationSupportARM & operator=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
+
+    PhysicalDeviceDataGraphOperationSupportARM & operator=( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
+      setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) VULKAN_HPP_NOEXCEPT
+    {
+      operationType = operationType_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
+      setName( std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name_ ) VULKAN_HPP_NOEXCEPT
+    {
+      name = name_;
+      return *this;
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    PhysicalDeviceDataGraphOperationSupportARM & setName( std::string const & name_ ) VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
+#    if defined( _WIN32 )
+      strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
+#    else
+      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
+#    endif
+      return *this;
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setVersion( uint32_t version_ ) VULKAN_HPP_NOEXCEPT
+    {
+      version = version_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_SETTERS*/
+
+    operator VkPhysicalDeviceDataGraphOperationSupportARM const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+    }
+
+    operator VkPhysicalDeviceDataGraphOperationSupportARM &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+    }
+
+    operator VkPhysicalDeviceDataGraphOperationSupportARM const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+    }
+
+    operator VkPhysicalDeviceDataGraphOperationSupportARM *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+    std::tuple<PhysicalDeviceDataGraphOperationTypeARM const &,
+               ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const &,
+               uint32_t const &>
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( operationType, name, version );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    std::strong_ordering operator<=>( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      if ( auto cmp = operationType <=> rhs.operationType; cmp != 0 )
+        return cmp;
+      if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 )
+        return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
+      if ( auto cmp = version <=> rhs.version; cmp != 0 )
+        return cmp;
+
+      return std::strong_ordering::equivalent;
+    }
+#endif
+
+    bool operator==( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( operationType == rhs.operationType ) && ( strcmp( name, rhs.name ) == 0 ) && ( version == rhs.version );
+    }
+
+    bool operator!=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+
+  public:
+    PhysicalDeviceDataGraphOperationTypeARM operationType = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet;
+    ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name    = {};
+    uint32_t                                                                            version = {};
+  };
+
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <>
+  struct CppType<VkPhysicalDeviceDataGraphOperationSupportARM>
+  {
+    using Type = PhysicalDeviceDataGraphOperationSupportARM;
+  };
+#endif
+
+  // wrapper struct for struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineBuiltinModelCreateInfoQCOM.html
+  struct DataGraphPipelineBuiltinModelCreateInfoQCOM
+  {
+    using NativeType = VkDataGraphPipelineBuiltinModelCreateInfoQCOM;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM;
+
+#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ = {},
+                                                                         const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , pOperation{ pOperation_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR_14
+      DataGraphPipelineBuiltinModelCreateInfoQCOM( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    DataGraphPipelineBuiltinModelCreateInfoQCOM( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+      : DataGraphPipelineBuiltinModelCreateInfoQCOM( *reinterpret_cast<DataGraphPipelineBuiltinModelCreateInfoQCOM const *>( &rhs ) )
+    {
+    }
+
+    DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
+
+    DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<DataGraphPipelineBuiltinModelCreateInfoQCOM const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM &
+      setPOperation( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pOperation = pOperation_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_SETTERS*/
+
+    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
+    }
+
+    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
+    }
+
+    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<const VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
+    }
+
+    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+    std::tuple<StructureType const &, const void * const &, const PhysicalDeviceDataGraphOperationSupportARM * const &> reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pOperation );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( DataGraphPipelineBuiltinModelCreateInfoQCOM const & ) const = default;
+#else
+    bool operator==( DataGraphPipelineBuiltinModelCreateInfoQCOM 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 ) && ( pOperation == rhs.pOperation );
+#  endif
+    }
+
+    bool operator!=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    StructureType                                      sType      = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM;
+    const void *                                       pNext      = {};
+    const PhysicalDeviceDataGraphOperationSupportARM * pOperation = {};
+  };
+
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <>
+  struct CppType<VkDataGraphPipelineBuiltinModelCreateInfoQCOM>
+  {
+    using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM;
+  };
+#endif
+
+  template <>
+  struct CppType<StructureType, StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM>
+  {
+    using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM;
+  };
+
   // wrapper struct for struct VkDataGraphPipelineCompilerControlCreateInfoARM, see
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineCompilerControlCreateInfoARM.html
   struct DataGraphPipelineCompilerControlCreateInfoARM
@@ -39031,61 +39294,19 @@ namespace VULKAN_HPP_NAMESPACE
     {
     }
 
-#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT( DeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 
     DeviceFaultInfoEXT( VkDeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceFaultInfoEXT( *reinterpret_cast<DeviceFaultInfoEXT const *>( &rhs ) ) {}
 
     DeviceFaultInfoEXT & operator=( DeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-#  else
+#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
-    DeviceFaultInfoEXT( DeviceFaultInfoEXT const & )             = delete;
-    DeviceFaultInfoEXT & operator=( DeviceFaultInfoEXT const & ) = delete;
 
-    DeviceFaultInfoEXT( DeviceFaultInfoEXT && rhs ) VULKAN_HPP_NOEXCEPT
+    DeviceFaultInfoEXT & operator=( VkDeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : pNext{ rhs.pNext }
-      , pAddressInfos{ rhs.pAddressInfos }
-      , pVendorInfos{ rhs.pVendorInfos }
-      , pVendorBinaryData{ rhs.pVendorBinaryData }
     {
-      memcpy( description, rhs.description, VK_MAX_DESCRIPTION_SIZE );
+      *this = *reinterpret_cast<DeviceFaultInfoEXT const *>( &rhs );
-
-      rhs.pNext = nullptr;
-      memset( rhs.description, 0, VK_MAX_DESCRIPTION_SIZE );
-      rhs.pAddressInfos     = nullptr;
-      rhs.pVendorInfos      = nullptr;
-      rhs.pVendorBinaryData = nullptr;
-    }
-
-    DeviceFaultInfoEXT & operator=( DeviceFaultInfoEXT && rhs ) VULKAN_HPP_NOEXCEPT
-    {
-      free( pAddressInfos );
-      free( pVendorInfos );
-      free( pVendorBinaryData );
-
-      pNext = rhs.pNext;
-      memcpy( description, rhs.description, VK_MAX_DESCRIPTION_SIZE );
-      pAddressInfos     = rhs.pAddressInfos;
-      pVendorInfos      = rhs.pVendorInfos;
-      pVendorBinaryData = rhs.pVendorBinaryData;
-
-      rhs.pNext = nullptr;
-      memset( rhs.description, 0, VK_MAX_DESCRIPTION_SIZE );
-      rhs.pAddressInfos     = nullptr;
-      rhs.pVendorInfos      = nullptr;
-      rhs.pVendorBinaryData = nullptr;
-
       return *this;
     }
 
-    ~DeviceFaultInfoEXT() VULKAN_HPP_NOEXCEPT
-    {
-      free( pAddressInfos );
-      free( pVendorInfos );
-      free( pVendorBinaryData );
-    }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VULKAN_HPP_NO_CONSTRUCTORS*/
-
     operator VkDeviceFaultInfoEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceFaultInfoEXT *>( this );
@@ -82469,155 +82690,117 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDataGraphFeaturesARM;
   };
 
-  // wrapper struct for struct VkPhysicalDeviceDataGraphOperationSupportARM, see
+  // wrapper struct for struct VkPhysicalDeviceDataGraphModelFeaturesQCOM, see
-  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationSupportARM.html
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphModelFeaturesQCOM.html
-  struct PhysicalDeviceDataGraphOperationSupportARM
+  struct PhysicalDeviceDataGraphModelFeaturesQCOM
   {
-    using NativeType = VkPhysicalDeviceDataGraphOperationSupportARM;
+    using NativeType = VkPhysicalDeviceDataGraphModelFeaturesQCOM;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM;
 
 #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM(
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphModelFeaturesQCOM( Bool32 dataGraphModel_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      PhysicalDeviceDataGraphOperationTypeARM operationType_ = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet,
+      : pNext{ pNext_ }
-      std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const & name_    = {},
+      , dataGraphModel{ dataGraphModel_ }
-      uint32_t                                                                                version_ = {} ) VULKAN_HPP_NOEXCEPT
-      : operationType{ operationType_ }
-      , name{ name_ }
-      , version{ version_ }
     {
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphModelFeaturesQCOM( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 
-    PhysicalDeviceDataGraphOperationSupportARM( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
+    PhysicalDeviceDataGraphModelFeaturesQCOM( VkPhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
-      : PhysicalDeviceDataGraphOperationSupportARM( *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs ) )
+      : PhysicalDeviceDataGraphModelFeaturesQCOM( *reinterpret_cast<PhysicalDeviceDataGraphModelFeaturesQCOM const *>( &rhs ) )
     {
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    PhysicalDeviceDataGraphModelFeaturesQCOM & operator=( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-    PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationTypeARM operationType_, std::string const & name_, uint32_t version_ = {} )
-      : operationType( operationType_ ), version( version_ )
-    {
-      VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
-#    if defined( _WIN32 )
-      strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
-#    else
-      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
-#    endif
-    }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    PhysicalDeviceDataGraphOperationSupportARM & operator=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 #endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
 
-    PhysicalDeviceDataGraphOperationSupportARM & operator=( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
+    PhysicalDeviceDataGraphModelFeaturesQCOM & operator=( VkPhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *this = *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs );
+      *this = *reinterpret_cast<PhysicalDeviceDataGraphModelFeaturesQCOM const *>( &rhs );
       return *this;
     }
 
 #if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
-      setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) VULKAN_HPP_NOEXCEPT
     {
-      operationType = operationType_;
+      pNext = pNext_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM & setDataGraphModel( Bool32 dataGraphModel_ ) VULKAN_HPP_NOEXCEPT
-      setName( std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name_ ) VULKAN_HPP_NOEXCEPT
     {
-      name = name_;
+      dataGraphModel = dataGraphModel_;
-      return *this;
-    }
-
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
-    PhysicalDeviceDataGraphOperationSupportARM & setName( std::string const & name_ ) VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
-#    if defined( _WIN32 )
-      strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
-#    else
-      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
-#    endif
-      return *this;
-    }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setVersion( uint32_t version_ ) VULKAN_HPP_NOEXCEPT
-    {
-      version = version_;
       return *this;
     }
 #endif /*VULKAN_HPP_NO_SETTERS*/
 
-    operator VkPhysicalDeviceDataGraphOperationSupportARM const &() const VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceDataGraphModelFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+      return *reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
     }
 
-    operator VkPhysicalDeviceDataGraphOperationSupportARM &() VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceDataGraphModelFeaturesQCOM &() VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+      return *reinterpret_cast<VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
     }
 
-    operator VkPhysicalDeviceDataGraphOperationSupportARM const *() const VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceDataGraphModelFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT
     {
-      return reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+      return reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
     }
 
-    operator VkPhysicalDeviceDataGraphOperationSupportARM *() VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceDataGraphModelFeaturesQCOM *() VULKAN_HPP_NOEXCEPT
     {
-      return reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+      return reinterpret_cast<VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
     }
 
 #if defined( VULKAN_HPP_USE_REFLECT )
-    std::tuple<PhysicalDeviceDataGraphOperationTypeARM const &,
+    std::tuple<StructureType const &, const void * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
-               ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const &,
-               uint32_t const &>
-      reflect() const VULKAN_HPP_NOEXCEPT
     {
-      return std::tie( operationType, name, version );
+      return std::tie( sType, pNext, dataGraphModel );
     }
 #endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
-    std::strong_ordering operator<=>( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    auto operator<=>( PhysicalDeviceDataGraphModelFeaturesQCOM const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      if ( auto cmp = operationType <=> rhs.operationType; cmp != 0 )
+#  if defined( VULKAN_HPP_USE_REFLECT )
-        return cmp;
+      return this->reflect() == rhs.reflect();
-      if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 )
+#  else
-        return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataGraphModel == rhs.dataGraphModel );
-      if ( auto cmp = version <=> rhs.version; cmp != 0 )
+#  endif
-        return cmp;
-
-      return std::strong_ordering::equivalent;
-    }
-#endif
-
-    bool operator==( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ( operationType == rhs.operationType ) && ( strcmp( name, rhs.name ) == 0 ) && ( version == rhs.version );
     }
 
-    bool operator!=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator!=( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
       return !operator==( rhs );
     }
+#endif
 
   public:
-    PhysicalDeviceDataGraphOperationTypeARM operationType = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet;
+    StructureType sType          = StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM;
-    ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name    = {};
+    const void *  pNext          = {};
-    uint32_t                                                                            version = {};
+    Bool32        dataGraphModel = {};
   };
 
 #if 20 <= VULKAN_HPP_CPP_VERSION
   template <>
-  struct CppType<VkPhysicalDeviceDataGraphOperationSupportARM>
+  struct CppType<VkPhysicalDeviceDataGraphModelFeaturesQCOM>
   {
-    using Type = PhysicalDeviceDataGraphOperationSupportARM;
+    using Type = PhysicalDeviceDataGraphModelFeaturesQCOM;
   };
 #endif
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM>
+  {
+    using Type = PhysicalDeviceDataGraphModelFeaturesQCOM;
+  };
+
   // wrapper struct for struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, see
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html
   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
@@ -90373,6 +90556,21 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE &
+      setFragmentDensityMapLayered( Bool32 fragmentDensityMapLayered_ ) VULKAN_HPP_NOEXCEPT
+    {
+      fragmentDensityMapLayered = fragmentDensityMapLayered_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_SETTERS*/
+
     operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *>( this );
@@ -126697,6 +126895,143 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCacheCreateInfo;
   };
 
+  // wrapper struct for struct VkPipelineCacheHeaderVersionDataGraphQCOM, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersionDataGraphQCOM.html
+  struct PipelineCacheHeaderVersionDataGraphQCOM
+  {
+    using NativeType = VkPipelineCacheHeaderVersionDataGraphQCOM;
+
+#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM(
+      uint32_t                                                                        headerSize_       = {},
+      PipelineCacheHeaderVersion                                                      headerVersion_    = PipelineCacheHeaderVersion::eOne,
+      DataGraphModelCacheTypeQCOM                                                     cacheType_        = DataGraphModelCacheTypeQCOM::eGenericBinary,
+      uint32_t                                                                        cacheVersion_     = {},
+      std::array<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> const & toolchainVersion_ = {} ) VULKAN_HPP_NOEXCEPT
+      : headerSize{ headerSize_ }
+      , headerVersion{ headerVersion_ }
+      , cacheType{ cacheType_ }
+      , cacheVersion{ cacheVersion_ }
+      , toolchainVersion{ toolchainVersion_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PipelineCacheHeaderVersionDataGraphQCOM( VkPipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PipelineCacheHeaderVersionDataGraphQCOM( *reinterpret_cast<PipelineCacheHeaderVersionDataGraphQCOM const *>( &rhs ) )
+    {
+    }
+
+    PipelineCacheHeaderVersionDataGraphQCOM & operator=( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
+
+    PipelineCacheHeaderVersionDataGraphQCOM & operator=( VkPipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<PipelineCacheHeaderVersionDataGraphQCOM const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setHeaderSize( uint32_t headerSize_ ) VULKAN_HPP_NOEXCEPT
+    {
+      headerSize = headerSize_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setHeaderVersion( PipelineCacheHeaderVersion headerVersion_ ) VULKAN_HPP_NOEXCEPT
+    {
+      headerVersion = headerVersion_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setCacheType( DataGraphModelCacheTypeQCOM cacheType_ ) VULKAN_HPP_NOEXCEPT
+    {
+      cacheType = cacheType_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setCacheVersion( uint32_t cacheVersion_ ) VULKAN_HPP_NOEXCEPT
+    {
+      cacheVersion = cacheVersion_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM &
+      setToolchainVersion( std::array<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> toolchainVersion_ ) VULKAN_HPP_NOEXCEPT
+    {
+      toolchainVersion = toolchainVersion_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_SETTERS*/
+
+    operator VkPipelineCacheHeaderVersionDataGraphQCOM const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
+    }
+
+    operator VkPipelineCacheHeaderVersionDataGraphQCOM &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
+    }
+
+    operator VkPipelineCacheHeaderVersionDataGraphQCOM const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<const VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
+    }
+
+    operator VkPipelineCacheHeaderVersionDataGraphQCOM *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+    std::tuple<uint32_t const &,
+               PipelineCacheHeaderVersion const &,
+               DataGraphModelCacheTypeQCOM const &,
+               uint32_t const &,
+               ArrayWrapper1D<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> const &>
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( headerSize, headerVersion, cacheType, cacheVersion, toolchainVersion );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PipelineCacheHeaderVersionDataGraphQCOM const & ) const = default;
+#else
+    bool operator==( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && ( cacheType == rhs.cacheType ) &&
+             ( cacheVersion == rhs.cacheVersion ) && ( toolchainVersion == rhs.toolchainVersion );
+#  endif
+    }
+
+    bool operator!=( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    uint32_t                                                                    headerSize       = {};
+    PipelineCacheHeaderVersion                                                  headerVersion    = PipelineCacheHeaderVersion::eOne;
+    DataGraphModelCacheTypeQCOM                                                 cacheType        = DataGraphModelCacheTypeQCOM::eGenericBinary;
+    uint32_t                                                                    cacheVersion     = {};
+    ArrayWrapper1D<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> toolchainVersion = {};
+  };
+
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <>
+  struct CppType<VkPipelineCacheHeaderVersionDataGraphQCOM>
+  {
+    using Type = PipelineCacheHeaderVersionDataGraphQCOM;
+  };
+#endif
+
   // wrapper struct for struct VkPipelineCacheHeaderVersionOne, see
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersionOne.html
   struct PipelineCacheHeaderVersionOne

include/vulkan/vulkan_to_string.hpp

@@ -5564,6 +5564,8 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT     : return "PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT";
       case StructureType::ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR     : return "PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR";
       case StructureType::ePhysicalDeviceShader64BitIndexingFeaturesEXT            : return "PhysicalDeviceShader64BitIndexingFeaturesEXT";
+      case StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM                : return "PhysicalDeviceDataGraphModelFeaturesQCOM";
+      case StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM             : return "DataGraphPipelineBuiltinModelCreateInfoQCOM";
       case StructureType::ePhysicalDeviceMaintenance10FeaturesKHR                  : return "PhysicalDeviceMaintenance10FeaturesKHR";
       case StructureType::ePhysicalDeviceMaintenance10PropertiesKHR                : return "PhysicalDeviceMaintenance10PropertiesKHR";
       case StructureType::eRenderingAttachmentFlagsInfoKHR                         : return "RenderingAttachmentFlagsInfoKHR";
@@ -6589,7 +6591,8 @@ namespace VULKAN_HPP_NAMESPACE
   {
     switch ( value )
     {
-      case PipelineCacheHeaderVersion::eOne: return "One";
+      case PipelineCacheHeaderVersion::eOne          : return "One";
+      case PipelineCacheHeaderVersion::eDataGraphQCOM: return "DataGraphQCOM";
       default                                        : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -10366,7 +10369,9 @@ namespace VULKAN_HPP_NAMESPACE
   {
     switch ( value )
     {
-      case PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault: return "Default";
+      case PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault    : return "Default";
+      case PhysicalDeviceDataGraphProcessingEngineTypeARM::eNeuralQCOM : return "NeuralQCOM";
+      case PhysicalDeviceDataGraphProcessingEngineTypeARM::eComputeQCOM: return "ComputeQCOM";
       default                                                          : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -10376,6 +10381,8 @@ namespace VULKAN_HPP_NAMESPACE
     switch ( value )
     {
       case PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet: return "SpirvExtendedInstructionSet";
+      case PhysicalDeviceDataGraphOperationTypeARM::eNeuralModelQCOM            : return "NeuralModelQCOM";
+      case PhysicalDeviceDataGraphOperationTypeARM::eBuiltinModelQCOM           : return "BuiltinModelQCOM";
       default                                                                   : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -10802,6 +10809,17 @@ namespace VULKAN_HPP_NAMESPACE
     return "(void)";
   }
 
+  //=== VK_QCOM_data_graph_model ===
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphModelCacheTypeQCOM value )
+  {
+    switch ( value )
+    {
+      case DataGraphModelCacheTypeQCOM::eGenericBinary: return "GenericBinary";
+      default                                         : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
+    }
+  }
+
   //=== VK_KHR_maintenance10 ===
 
   VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderingAttachmentFlagBitsKHR value )

registry/vk.xml

@@ -183,7 +183,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,vulkanbase" category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 331</type>
+#define <name>VK_HEADER_VERSION</name> 332</type>
         <type api="vulkan,vulkanbase" 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, 4, VK_HEADER_VERSION)</type>
         <type api="vulkansc" category="define">// Version of this file
@@ -897,6 +897,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
         <type name="VkDataGraphPipelineDispatchFlagBitsARM" category="enum"/>
         <type name="VkPhysicalDeviceDataGraphProcessingEngineTypeARM" category="enum"/>
         <type name="VkPhysicalDeviceDataGraphOperationTypeARM" category="enum"/>
+        <type name="VkDataGraphModelCacheTypeQCOM" category="enum"/>
         <type name="VkVideoEncodeRgbModelConversionFlagBitsVALVE" category="enum"/>
         <type name="VkVideoEncodeRgbRangeCompressionFlagBitsVALVE" category="enum"/>
         <type name="VkVideoEncodeRgbChromaOffsetFlagBitsVALVE" category="enum"/>
@@ -1813,6 +1814,14 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member><type>uint32_t</type>                               <name>pipelineIndexStride</name></member>
             <member><type>uint64_t</type>                               <name>pipelineIndexOffset</name></member>
         </type>
+        <type category="struct" name="VkPipelineCacheHeaderVersionDataGraphQCOM">
+            <comment>The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout.</comment>
+            <member><type>uint32_t</type>                      <name>headerSize</name></member>
+            <member><type>VkPipelineCacheHeaderVersion</type>  <name>headerVersion</name></member>
+            <member><type>VkDataGraphModelCacheTypeQCOM</type> <name>cacheType</name></member>
+            <member><type>uint32_t</type>                      <name>cacheVersion</name></member>
+            <member><type>uint32_t</type>                      <name>toolchainVersion</name>[<enum>VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM</enum>]</member>
+        </type>
         <type category="struct" name="VkPushConstantRange">
             <member><type>VkShaderStageFlags</type>     <name>stageFlags</name><comment>Which stages use the range</comment></member>
             <member><type>uint32_t</type>               <name>offset</name><comment>Start of the range, in bytes</comment></member>
@@ -10545,7 +10554,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member optional="true"><type>void</type>*                            <name>pNext</name></member>
             <member limittype="max"><type>uint32_t</type>                         <name>maxFragmentDensityMapLayers</name></member>
         </type>
-        <type category="struct" name="VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE" returnedonly="true" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+        <type category="struct" name="VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*                            <name>pNext</name></member>
             <member><type>VkBool32</type>                                         <name>fragmentDensityMapLayered</name></member>
@@ -10927,6 +10936,16 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member optional="true"><type>void</type>*            <name>pNext</name></member>
             <member><type>VkBool32</type>                         <name>pipelineCacheIncrementalMode</name></member>
         </type>
+        <type category="struct" name="VkDataGraphPipelineBuiltinModelCreateInfoQCOM" structextends="VkDataGraphPipelineCreateInfoARM">
+            <member values="VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true">const <type>void</type>*                                                                   <name>pNext</name></member>
+            <member>const <type>VkPhysicalDeviceDataGraphOperationSupportARM</type>*                                           <name>pOperation</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceDataGraphModelFeaturesQCOM" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true">const <type>void</type>*                                                               <name>pNext</name></member>
+            <member featurelink="dataGraphModelQCOM"><type>VkBool32</type>                                                 <name>dataGraphModel</name></member>
+        </type>
         <type category="struct" name="VkPhysicalDeviceShaderUntypedPointersFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*          <name>pNext</name></member>
@@ -11089,6 +11108,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
         <enum type="uint32_t" value="128"       name="VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX"/>
         <enum type="uint32_t" value="128"       name="VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX"/>
         <enum type="uint32_t" value="128"       name="VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM"/>
+        <enum type="uint32_t" value="3"         name="VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM"/>
     </enums>
 
     <comment>
@@ -13332,6 +13352,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
     <enums name="VkPhysicalDeviceDataGraphOperationTypeARM" type="enum">
         <enum value="0"      name="VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM"/>
     </enums>
+    <enums name="VkDataGraphModelCacheTypeQCOM" type="enum">
+        <enum value="0"      name="VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM"/>
+    </enums>
     <enums name="VkVideoEncodeRgbModelConversionFlagBitsVALVE" type="bitmask">
         <enum bitpos="0"  name="VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE"/>
         <enum bitpos="1"  name="VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE"/>
@@ -17790,7 +17813,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
         <command conditionalrendering="false" queues="VK_QUEUE_TRANSFER_BIT,VK_QUEUE_GRAPHICS_BIT,VK_QUEUE_COMPUTE_BIT" renderpass="outside" cmdbufferlevel="primary,secondary" tasks="action">
             <proto><type>void</type> <name>vkCmdCopyTensorARM</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
-            <param> const <type>VkCopyTensorInfoARM</type>* <name>pCopyTensorInfo</name></param>
+            <param>const <type>VkCopyTensorInfoARM</type>* <name>pCopyTensorInfo</name></param>
         </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_UNKNOWN,VK_ERROR_VALIDATION_FAILED">
             <proto><type>VkResult</type> <name>vkGetTensorOpaqueCaptureDescriptorDataARM</name></proto>
@@ -24465,7 +24488,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_QCOM_extension_307&quot;"             name="VK_QCOM_EXTENSION_307_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_NV_cuda_kernel_launch" number="308" type="device" author="NV" contact="Tristan Lorach @tlorach" supported="vulkan" provisional="true" platform="provisional">
+        <extension name="VK_NV_cuda_kernel_launch" number="308" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="NV" contact="Tristan Lorach @tlorach" supported="vulkan" provisional="true" platform="provisional">
             <require>
                 <enum value="2"                                             name="VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_cuda_kernel_launch&quot;"          name="VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME"/>
@@ -25567,7 +25590,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="sciBufImport,sciBufExport" struct="VkPhysicalDeviceExternalSciBufFeaturesNV"/>
             </require>
         </extension>
-        <extension name="VK_EXT_frame_boundary" number="376" type="device" author="EXT" contact="James Fitzpatrick @jamesfitzpatrick" supported="vulkan" ratified="vulkan">
+        <extension name="VK_EXT_frame_boundary" number="376" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="EXT" contact="James Fitzpatrick @jamesfitzpatrick" supported="vulkan" ratified="vulkan">
             <require>
                 <enum value="1"                                         name="VK_EXT_FRAME_BOUNDARY_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_frame_boundary&quot;"         name="VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME"/>
@@ -26041,7 +26064,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <type name="VkPhysicalDeviceShaderCorePropertiesARM"/>
             </require>
         </extension>
-        <extension name="VK_KHR_shader_subgroup_rotate" number="417" author="KHR" contact="Kevin Petit @kpet" type="device" supported="vulkan" promotedto="VK_VERSION_1_4" ratified="vulkan">
+        <extension name="VK_KHR_shader_subgroup_rotate" number="417" author="KHR" contact="Kevin Petit @kpet" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" supported="vulkan" promotedto="VK_VERSION_1_4" ratified="vulkan">
             <require>
                 <enum value="2"                                         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"/>
@@ -26406,7 +26429,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
         </extension>
         <extension name="VK_OHOS_external_memory" number="453" type="device" author="HUAWEI" depends="((VK_KHR_sampler_ycbcr_conversion+VK_KHR_external_memory+VK_KHR_dedicated_allocation),VK_VERSION_1_1)+VK_EXT_queue_family_foreign" platform="ohos" contact="Weilan Chen @wchen-h" supported="vulkan" nofeatures="true">
             <require>
-                <enum value="2"                                             name="VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION"/>
+                <enum value="1"                                             name="VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION"/>
                 <enum value="&quot;VK_OHOS_external_memory&quot;"           name="VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS"/>
                 <enum offset="1" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS"/>
@@ -27012,7 +27035,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_AMD_extension_476&quot;"          name="VK_AMD_EXTENSION_476_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_AMD_anti_lag" number="477" type="device" author="AMD" contact="Stu Smith" supported="vulkan">
+        <extension name="VK_AMD_anti_lag" number="477" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="AMD" contact="Stu Smith" supported="vulkan">
             <require>
                 <enum value="1"                                         name="VK_AMD_ANTI_LAG_SPEC_VERSION"/>
                 <enum value="&quot;VK_AMD_anti_lag&quot;"               name="VK_AMD_ANTI_LAG_EXTENSION_NAME"/>
@@ -27386,7 +27409,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="rayTracingInvocationReorder" struct="VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV"/>
             </require>
         </extension>
-        <extension name="VK_NV_cooperative_vector" number="492" author="NV" type="device" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
+        <extension name="VK_NV_cooperative_vector" number="492" author="NV" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
             <require>
                 <enum value="4"                                                 name="VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_cooperative_vector&quot;"              name="VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME"/>
@@ -27413,7 +27436,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="cooperativeVector" struct="VkPhysicalDeviceCooperativeVectorFeaturesNV"/>
             </require>
         </extension>
-        <extension name="VK_NV_extended_sparse_address_space" number="493" type="device" author="NV" contact="Russell Chou @russellcnv" supported="vulkan">
+        <extension name="VK_NV_extended_sparse_address_space" number="493" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Russell Chou @russellcnv" supported="vulkan">
             <require>
                 <enum value="1"                                               name="VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_extended_sparse_address_space&quot;" name="VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME"/>
@@ -27667,7 +27690,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_MESA_extension_510&quot;"             name="VK_MESA_EXTENSION_510_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_QCOM_multiview_per_view_render_areas" number="511" type="device" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan">
+        <extension name="VK_QCOM_multiview_per_view_render_areas" number="511" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan">
             <require>
                 <enum value="1"                                                   name="VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION"/>
                 <enum value="&quot;VK_QCOM_multiview_per_view_render_areas&quot;" name="VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME"/>
@@ -27825,7 +27848,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="selectableCubicWeights" struct="VkPhysicalDeviceCubicWeightsFeaturesQCOM"/>
             </require>
         </extension>
-        <extension name="VK_QCOM_ycbcr_degamma" number="521" type="device" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan">
+        <extension name="VK_QCOM_ycbcr_degamma" number="521" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan">
             <require>
                 <enum value="1"                                                   name="VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION"/>
                 <enum value="&quot;VK_QCOM_ycbcr_degamma&quot;"                   name="VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME"/>
@@ -27891,7 +27914,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum extends="VkAttachmentStoreOp" name="VK_ATTACHMENT_STORE_OP_NONE_KHR" alias="VK_ATTACHMENT_STORE_OP_NONE"/>
             </require>
         </extension>
-        <extension name="VK_KHR_unified_image_layouts" number="528" author="KHR" type="device" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" ratified="vulkan">
+        <extension name="VK_KHR_unified_image_layouts" number="528" author="KHR" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" ratified="vulkan">
             <require>
                 <enum value="1"                                                 name="VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_unified_image_layouts&quot;"          name="VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME"/>
@@ -28274,7 +28297,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_IMG_extension_555&quot;"              name="VK_IMG_EXTENSION_555_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_NV_raw_access_chains" number="556" type="device" author="NV" contact="Rodrigo Locatti @rlocatti" supported="vulkan">
+        <extension name="VK_NV_raw_access_chains" number="556" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Rodrigo Locatti @rlocatti" supported="vulkan">
             <require>
                 <enum value="1"                                             name="VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_raw_access_chains&quot;"           name="VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME"/>
@@ -28308,7 +28331,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_KHR_extension_558&quot;"              name="VK_KHR_EXTENSION_558_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_KHR_shader_relaxed_extended_instruction" number="559" type="device" author="KHR" contact="Nathan Gauër @Keenuts" supported="vulkan" ratified="vulkan">
+        <extension name="VK_KHR_shader_relaxed_extended_instruction" number="559" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="KHR" contact="Nathan Gauër @Keenuts" supported="vulkan" ratified="vulkan">
             <require>
                 <enum value="1"                                                       name="VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_shader_relaxed_extended_instruction&quot;"  name="VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME"/>
@@ -28317,7 +28340,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="shaderRelaxedExtendedInstruction" struct="VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR"/>
             </require>
         </extension>
-        <extension name="VK_NV_command_buffer_inheritance" number="560" type="device" author="NV" contact="Lujin Wang @lujinwangnv" supported="vulkan">
+        <extension name="VK_NV_command_buffer_inheritance" number="560" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="NV" contact="Lujin Wang @lujinwangnv" supported="vulkan">
             <require>
                 <enum value="1"                                             name="VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_command_buffer_inheritance&quot;"  name="VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME"/>
@@ -28358,7 +28381,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="maintenance7" struct="VkPhysicalDeviceMaintenance7FeaturesKHR"/>
             </require>
         </extension>
-        <extension name="VK_NV_shader_atomic_float16_vector" number="564" type="device" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
+        <extension name="VK_NV_shader_atomic_float16_vector" number="564" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
             <require>
                 <enum value="1"                                             name="VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_shader_atomic_float16_vector&quot;" name="VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME"/>
@@ -28367,7 +28390,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="shaderFloat16VectorAtomics" struct="VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV"/>
             </require>
         </extension>
-        <extension name="VK_EXT_shader_replicated_composites" number="565" type="device" author="EXT" contact="Kevin Petit @kpet" supported="vulkan" ratified="vulkan">
+        <extension name="VK_EXT_shader_replicated_composites" number="565" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="EXT" contact="Kevin Petit @kpet" supported="vulkan" ratified="vulkan">
             <require>
                 <enum value="1"                                               name="VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_shader_replicated_composites&quot;" name="VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME"/>
@@ -28388,7 +28411,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_ARM_extension_567&quot;"              name="VK_ARM_EXTENSION_567_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_EXT_shader_float8" number="568" author="EXT" contact="Kevin Petit @kpet" type="device" supported="vulkan" ratified="vulkan">
+        <extension name="VK_EXT_shader_float8" number="568" author="EXT" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Kevin Petit @kpet" type="device" supported="vulkan" ratified="vulkan">
             <require>
                 <enum value="1"                                          name="VK_EXT_SHADER_FLOAT8_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_shader_float8&quot;"           name="VK_EXT_SHADER_FLOAT8_EXTENSION_NAME"/>
@@ -28401,7 +28424,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum offset="3" extnumber="492" extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT"/>
             </require>
         </extension>
-        <extension name="VK_NV_ray_tracing_validation" number="569" type="device" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan">
+        <extension name="VK_NV_ray_tracing_validation" number="569" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan">
             <require>
                 <enum value="1"                                             name="VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_ray_tracing_validation&quot;"      name="VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME"/>
@@ -28624,7 +28647,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum bitpos="9" extends="VkShaderCreateFlagBitsEXT"        name="VK_SHADER_CREATE_RESERVED_9_BIT_EXT"/>
             </require>
         </extension>
-        <extension name="VK_KHR_shader_fma" number="580" type="device" author="KHR" contact="Graeme Leese @gnl21" supported="vulkan" ratified="vulkan">
+        <extension name="VK_KHR_shader_fma" number="580" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="KHR" contact="Graeme Leese @gnl21" supported="vulkan" ratified="vulkan">
             <require>
                 <enum value="1"                                  name="VK_KHR_SHADER_FMA_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_shader_fma&quot;"      name="VK_KHR_SHADER_FMA_EXTENSION_NAME"/>
@@ -28925,7 +28948,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="vertexAttributeRobustness" struct="VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT"/>
             </require>
         </extension>
-        <extension name="VK_ARM_format_pack" number="610" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan">
+        <extension name="VK_ARM_format_pack" number="610" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan">
             <require>
                 <enum value="1"                                             name="VK_ARM_FORMAT_PACK_SPEC_VERSION"/>
                 <enum value="&quot;VK_ARM_format_pack&quot;"               name="VK_ARM_FORMAT_PACK_EXTENSION_NAME"/>
@@ -28981,7 +29004,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="robustBufferAccess2,robustImageAccess2,nullDescriptor" struct="VkPhysicalDeviceRobustness2FeaturesKHR"/>
             </require>
         </extension>
-        <extension name="VK_NV_present_metering" number="614" type="device" author="NV" contact="Charles Hansen @chansen" supported="vulkan" provisional="true" platform="provisional">
+        <extension name="VK_NV_present_metering" number="614" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Charles Hansen @chansen" supported="vulkan" provisional="true" platform="provisional">
             <require>
                 <enum value="1"                                             name="VK_NV_PRESENT_METERING_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_present_metering&quot;"            name="VK_NV_PRESENT_METERING_EXTENSION_NAME"/>
@@ -29113,10 +29136,23 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum bitpos="5" extends="VkResolveModeFlagBits"            name="VK_RESOLVE_MODE_RESERVED_5_BIT_EXT"/>
             </require>
         </extension>
-        <extension name="VK_EXT_extension_630" number="630" author="EXT" contact="Matthew Netsch @mnetsch" supported="disabled">
+        <extension name="VK_QCOM_data_graph_model" number="630" author="QCOM" type="device" depends="VK_ARM_data_graph" contact="Matthew Netsch @mnetsch" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_EXT_EXTENSION_630_SPEC_VERSION"/>
+                <enum value="1"                                                             name="VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION"/>
-                <enum value="&quot;VK_EXT_extension_630&quot;"              name="VK_EXT_EXTENSION_630_EXTENSION_NAME"/>
+                <enum value="&quot;VK_QCOM_data_graph_model&quot;"                          name="VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM"/>
+                <enum offset="1" extends="VkStructureType"                                  name="VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM"/>
+                <enum offset="0" extends="VkPhysicalDeviceDataGraphProcessingEngineTypeARM" name="VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM"/>
+                <enum offset="1" extends="VkPhysicalDeviceDataGraphProcessingEngineTypeARM" name="VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM"/>
+                <enum offset="0" extends="VkPhysicalDeviceDataGraphOperationTypeARM"        name="VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM"/>
+                <enum offset="1" extends="VkPhysicalDeviceDataGraphOperationTypeARM"        name="VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM"/>
+                <enum offset="0" extends="VkPipelineCacheHeaderVersion"                     name="VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM"/>
+                <enum name="VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM"/>
+                <type name="VkDataGraphModelCacheTypeQCOM"/>
+                <type name="VkPipelineCacheHeaderVersionDataGraphQCOM"/>
+                <type name="VkDataGraphPipelineBuiltinModelCreateInfoQCOM"/>
+                <type name="VkPhysicalDeviceDataGraphModelFeaturesQCOM"/>
+                <feature name="dataGraphModel" struct="VkPhysicalDeviceDataGraphModelFeaturesQCOM"/>
             </require>
         </extension>
         <extension name="VK_KHR_maintenance10" number="631" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="KHR" contact="Mike Blumenkrantz @zmike" supported="vulkan" ratified="vulkan">
@@ -29200,7 +29236,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_EXT_extension_637&quot;"              name="VK_EXT_EXTENSION_637_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_SEC_pipeline_cache_incremental_mode" number="638" author="SEC" contact="Chris Hambacher @chambacher" type="device" supported="vulkan">
+        <extension name="VK_SEC_pipeline_cache_incremental_mode" number="638" author="SEC" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Chris Hambacher @chambacher" type="device" supported="vulkan">
             <require>
                 <enum value="1"                                                     name="VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION"/>
                 <enum value="&quot;VK_SEC_pipeline_cache_incremental_mode&quot;"    name="VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME"/>
@@ -29234,7 +29270,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_EXT_extension_642&quot;"              name="VK_EXT_EXTENSION_642_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_EXT_shader_uniform_buffer_unsized_array" number="643" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan" ratified="vulkan">
+        <extension name="VK_EXT_shader_uniform_buffer_unsized_array" number="643" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan" ratified="vulkan">
             <require>
                 <enum value="1" name="VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_shader_uniform_buffer_unsized_array&quot;" name="VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME"/>