Update for Vulkan-Docs 1.2.202v1.2.202

8 files changed, 17181 insertions, 526 deletions

diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index b66577c..0445ff1 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -119,7 +119,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <span>
 #endif
 
-static_assert( VK_HEADER_VERSION == 201, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 202, "Wrong VK_HEADER_VERSION!" );
 
 // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
 // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@@ -234,6 +234,11 @@ static_assert( VK_HEADER_VERSION == 201, "Wrong VK_HEADER_VERSION!" );
 #  define VULKAN_HPP_NAMESPACE vk
 #endif
 
+#if !defined( VULKAN_HPP_HASH_COMBINE )
+#  define VULKAN_HPP_HASH_COMBINE( valueType, seed, value ) \
+    seed ^= std::hash<std::remove_const<valueType>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 )
+#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 )
@@ -813,7 +818,20 @@ namespace VULKAN_HPP_NAMESPACE
   {
     return flags.operator^( bit );
   }
+}  // namespace VULKAN_HPP_NAMESPACE
 
+template <typename BitType>
+struct std::hash<VULKAN_HPP_NAMESPACE::Flags<BitType>>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags<BitType> const & flags ) const VULKAN_HPP_NOEXCEPT
+  {
+    return std::hash<typename std::underlying_type<BitType>::type>{}(
+      static_cast<typename std::underlying_type<BitType>::type>( flags ) );
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   template <typename RefType>
   class Optional
   {
@@ -14208,486 +14226,4 @@ namespace VULKAN_HPP_NAMESPACE
     }
   };
 }  // namespace VULKAN_HPP_NAMESPACE
-
-namespace std
-{
-  //=======================
-  //=== HASH structures ===
-  //=======================
-
-  template <typename BitType>
-  struct hash<VULKAN_HPP_NAMESPACE::Flags<BitType>>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags<BitType> const & flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<typename std::underlying_type<BitType>::type>{}(
-        static_cast<typename std::underlying_type<BitType>::type>( flags ) );
-    }
-  };
-
-  //=== VK_VERSION_1_0 ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Instance>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Device>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Queue>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Fence>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkFence>{}( static_cast<VkFence>( fence ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Semaphore>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Event>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::QueryPool>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Buffer>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::BufferView>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Image>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkImage>{}( static_cast<VkImage>( image ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::ImageView>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::ShaderModule>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PipelineCache>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Pipeline>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Sampler>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
-  {
-    std::size_t
-      operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Framebuffer>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::RenderPass>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
-    }
-  };
-
-  //=== VK_VERSION_1_1 ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDescriptorUpdateTemplate>{}(
-        static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) );
-    }
-  };
-
-  //=== VK_KHR_surface ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) );
-    }
-  };
-
-  //=== VK_KHR_swapchain ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) );
-    }
-  };
-
-  //=== VK_KHR_display ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) );
-    }
-  };
-
-  //=== VK_EXT_debug_report ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) );
-    }
-  };
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  //=== VK_KHR_video_queue ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkVideoSessionKHR>{}( static_cast<VkVideoSessionKHR>( videoSessionKHR ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkVideoSessionParametersKHR>{}(
-        static_cast<VkVideoSessionParametersKHR>( videoSessionParametersKHR ) );
-    }
-  };
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  //=== VK_NVX_binary_import ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkCuModuleNVX>{}( static_cast<VkCuModuleNVX>( cuModuleNVX ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkCuFunctionNVX>{}( static_cast<VkCuFunctionNVX>( cuFunctionNVX ) );
-    }
-  };
-
-  //=== VK_EXT_debug_utils ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) );
-    }
-  };
-
-  //=== VK_KHR_acceleration_structure ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkAccelerationStructureKHR>{}(
-        static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) );
-    }
-  };
-
-  //=== VK_EXT_validation_cache ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
-  {
-    std::size_t
-      operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) );
-    }
-  };
-
-  //=== VK_NV_ray_tracing ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkAccelerationStructureNV>{}(
-        static_cast<VkAccelerationStructureNV>( accelerationStructureNV ) );
-    }
-  };
-
-  //=== VK_INTEL_performance_query ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL )
-      const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPerformanceConfigurationINTEL>{}(
-        static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) );
-    }
-  };
-
-  //=== VK_KHR_deferred_host_operations ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
-  {
-    std::size_t
-      operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) );
-    }
-  };
-
-  //=== VK_NV_device_generated_commands ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkIndirectCommandsLayoutNV>{}(
-        static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) );
-    }
-  };
-
-  //=== VK_EXT_private_data ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>
-  {
-    std::size_t
-      operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & privateDataSlotEXT ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkPrivateDataSlotEXT>{}( static_cast<VkPrivateDataSlotEXT>( privateDataSlotEXT ) );
-    }
-  };
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  //=== VK_FUCHSIA_buffer_collection ===
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkBufferCollectionFUCHSIA>{}(
-        static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) );
-    }
-  };
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-}  // namespace std
 #endif
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index 56d4a20..f6e07ce 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -72,7 +72,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 201
+#define VK_HEADER_VERSION 202
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION)
@@ -1883,6 +1883,7 @@ typedef enum VkImageAspectFlagBits {
     VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100,
     VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200,
     VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400,
+    VK_IMAGE_ASPECT_NONE_KHR = 0,
     VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
     VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
     VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
@@ -8380,12 +8381,12 @@ typedef struct VkCheckpointData2NV {
 } VkCheckpointData2NV;
 
 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer                   commandBuffer, VkEvent                                             event, const VkDependencyInfoKHR*                          pDependencyInfo);
-typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer                   commandBuffer, VkEvent                                             event, VkPipelineStageFlags2KHR                            stageMask);
+typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer                   commandBuffer, VkEvent                                             event, VkPipelineStageFlags2KHR            stageMask);
 typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer                   commandBuffer, uint32_t                                            eventCount, const VkEvent*                     pEvents, const VkDependencyInfoKHR*         pDependencyInfos);
 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer                   commandBuffer, const VkDependencyInfoKHR*                                pDependencyInfo);
-typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2KHR                            stage, VkQueryPool                                         queryPool, uint32_t                                            query);
+typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2KHR            stage, VkQueryPool                                         queryPool, uint32_t                                            query);
 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue                           queue, uint32_t                            submitCount, const VkSubmitInfo2KHR*           pSubmits, VkFence           fence);
-typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2KHR                            stage, VkBuffer                                            dstBuffer, VkDeviceSize                                        dstOffset, uint32_t                                            marker);
+typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2KHR            stage, VkBuffer                                            dstBuffer, VkDeviceSize                                        dstOffset, uint32_t                                            marker);
 typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData);
 
 #ifndef VK_NO_PROTOTYPES
diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp
index 6fedc0c..3ce4796 100644
--- a/include/vulkan/vulkan_enums.hpp
+++ b/include/vulkan/vulkan_enums.hpp
@@ -3083,6 +3083,7 @@ namespace VULKAN_HPP_NAMESPACE
     eMemoryPlane1EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT,
     eMemoryPlane2EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT,
     eMemoryPlane3EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT,
+    eNoneKHR         = VK_IMAGE_ASPECT_NONE_KHR,
     ePlane0KHR       = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR,
     ePlane1KHR       = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR,
     ePlane2KHR       = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR
@@ -3103,6 +3104,7 @@ namespace VULKAN_HPP_NAMESPACE
       case ImageAspectFlagBits::eMemoryPlane1EXT: return "MemoryPlane1EXT";
       case ImageAspectFlagBits::eMemoryPlane2EXT: return "MemoryPlane2EXT";
       case ImageAspectFlagBits::eMemoryPlane3EXT: return "MemoryPlane3EXT";
+      case ImageAspectFlagBits::eNoneKHR: return "NoneKHR";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -12425,7 +12427,7 @@ namespace VULKAN_HPP_NAMESPACE
                  VkFlags( ImageAspectFlagBits::ePlane0 ) | VkFlags( ImageAspectFlagBits::ePlane1 ) |
                  VkFlags( ImageAspectFlagBits::ePlane2 ) | VkFlags( ImageAspectFlagBits::eMemoryPlane0EXT ) |
                  VkFlags( ImageAspectFlagBits::eMemoryPlane1EXT ) | VkFlags( ImageAspectFlagBits::eMemoryPlane2EXT ) |
-                 VkFlags( ImageAspectFlagBits::eMemoryPlane3EXT )
+                 VkFlags( ImageAspectFlagBits::eMemoryPlane3EXT ) | VkFlags( ImageAspectFlagBits::eNoneKHR )
     };
   };
 
diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp
index 28cdc42..b3aa99c 100644
--- a/include/vulkan/vulkan_handles.hpp
+++ b/include/vulkan/vulkan_handles.hpp
@@ -14531,4 +14531,476 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 }  // namespace VULKAN_HPP_NAMESPACE
+
+namespace std
+{
+  //=======================
+  //=== HASH structures ===
+  //=======================
+
+  //=== VK_VERSION_1_0 ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Instance>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Device>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Queue>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Fence>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkFence>{}( static_cast<VkFence>( fence ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Semaphore>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Event>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::QueryPool>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Buffer>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::BufferView>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Image>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkImage>{}( static_cast<VkImage>( image ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ImageView>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ShaderModule>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PipelineCache>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Pipeline>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Sampler>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Framebuffer>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderPass>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
+    }
+  };
+
+  //=== VK_VERSION_1_1 ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkDescriptorUpdateTemplate>{}(
+        static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) );
+    }
+  };
+
+  //=== VK_KHR_surface ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) );
+    }
+  };
+
+  //=== VK_KHR_swapchain ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) );
+    }
+  };
+
+  //=== VK_KHR_display ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) );
+    }
+  };
+
+  //=== VK_EXT_debug_report ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) );
+    }
+  };
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+  //=== VK_KHR_video_queue ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkVideoSessionKHR>{}( static_cast<VkVideoSessionKHR>( videoSessionKHR ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkVideoSessionParametersKHR>{}(
+        static_cast<VkVideoSessionParametersKHR>( videoSessionParametersKHR ) );
+    }
+  };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+  //=== VK_NVX_binary_import ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkCuModuleNVX>{}( static_cast<VkCuModuleNVX>( cuModuleNVX ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkCuFunctionNVX>{}( static_cast<VkCuFunctionNVX>( cuFunctionNVX ) );
+    }
+  };
+
+  //=== VK_EXT_debug_utils ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) );
+    }
+  };
+
+  //=== VK_KHR_acceleration_structure ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkAccelerationStructureKHR>{}(
+        static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) );
+    }
+  };
+
+  //=== VK_EXT_validation_cache ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) );
+    }
+  };
+
+  //=== VK_NV_ray_tracing ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkAccelerationStructureNV>{}(
+        static_cast<VkAccelerationStructureNV>( accelerationStructureNV ) );
+    }
+  };
+
+  //=== VK_INTEL_performance_query ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL )
+      const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkPerformanceConfigurationINTEL>{}(
+        static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) );
+    }
+  };
+
+  //=== VK_KHR_deferred_host_operations ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) );
+    }
+  };
+
+  //=== VK_NV_device_generated_commands ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkIndirectCommandsLayoutNV>{}(
+        static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) );
+    }
+  };
+
+  //=== VK_EXT_private_data ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & privateDataSlotEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkPrivateDataSlotEXT>{}( static_cast<VkPrivateDataSlotEXT>( privateDataSlotEXT ) );
+    }
+  };
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+  //=== VK_FUCHSIA_buffer_collection ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkBufferCollectionFUCHSIA>{}(
+        static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) );
+    }
+  };
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+}  // namespace std
 #endif
diff --git a/include/vulkan/vulkan_raii.hpp b/include/vulkan/vulkan_raii.hpp
index 5b243a5..f5827b9 100644
--- a/include/vulkan/vulkan_raii.hpp
+++ b/include/vulkan/vulkan_raii.hpp
@@ -5165,8 +5165,9 @@ namespace VULKAN_HPP_NAMESPACE
       void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                     event,
                          const VULKAN_HPP_NAMESPACE::DependencyInfoKHR & dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
 
-      void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
-                           VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask ) const VULKAN_HPP_NOEXCEPT;
+      void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
+                           VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask
+                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
       void waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &             events,
                            ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos ) const
diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp
index d1e260a..48d6e24 100644
--- a/include/vulkan/vulkan_structs.hpp
+++ b/include/vulkan/vulkan_structs.hpp
@@ -127,6 +127,26 @@ namespace VULKAN_HPP_NAMESPACE
                             "AabbPositionsKHR is not nothrow_move_constructible!" );
   using AabbPositionsNV = AabbPositionsKHR;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minX );
+    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minY );
+    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minZ );
+    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxX );
+    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxY );
+    VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxZ );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   union DeviceOrHostAddressConstKHR
   {
     using NativeType = VkDeviceOrHostAddressConstKHR;
@@ -1030,6 +1050,25 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR>::value,
     "AccelerationStructureBuildRangeInfoKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const &
+                            accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.primitiveCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.firstVertex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.transformOffset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AccelerationStructureBuildSizesInfoKHR
   {
     using NativeType = VkAccelerationStructureBuildSizesInfoKHR;
@@ -1145,6 +1184,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureBuildSizesInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const &
+                            accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureBuildSizesInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureBuildSizesInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AccelerationStructureCreateInfoKHR
   {
     using NativeType = VkAccelerationStructureCreateInfoKHR;
@@ -1290,6 +1352,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const &
+                            accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagsKHR, seed, accelerationStructureCreateInfoKHR.createFlags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, accelerationStructureCreateInfoKHR.buffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoKHR.offset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoKHR.size );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR, seed, accelerationStructureCreateInfoKHR.type );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceAddress, seed, accelerationStructureCreateInfoKHR.deviceAddress );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct GeometryTrianglesNV
   {
     using NativeType = VkGeometryTrianglesNV;
@@ -1478,6 +1566,34 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GeometryTrianglesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryTrianglesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryTrianglesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.vertexData );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.vertexOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryTrianglesNV.vertexCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.vertexStride );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, geometryTrianglesNV.vertexFormat );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.indexData );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.indexOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryTrianglesNV.indexCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndexType, seed, geometryTrianglesNV.indexType );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.transformData );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.transformOffset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct GeometryAABBNV
   {
     using NativeType = VkGeometryAABBNV;
@@ -1589,6 +1705,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GeometryAABBNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryAABBNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryAABBNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryAABBNV.aabbData );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryAABBNV.numAABBs );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryAABBNV.stride );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryAABBNV.offset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct GeometryDataNV
   {
     using NativeType = VkGeometryDataNV;
@@ -1666,6 +1802,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::GeometryDataNV>::value,
                             "GeometryDataNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::GeometryDataNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV, seed, geometryDataNV.triangles );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryAABBNV, seed, geometryDataNV.aabbs );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct GeometryNV
   {
     using NativeType = VkGeometryNV;
@@ -1771,6 +1923,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GeometryNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::GeometryNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryTypeKHR, seed, geometryNV.geometryType );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryDataNV, seed, geometryNV.geometry );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryFlagsKHR, seed, geometryNV.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AccelerationStructureInfoNV
   {
     using NativeType = VkAccelerationStructureInfoNV;
@@ -1926,6 +2097,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV, seed, accelerationStructureInfoNV.type );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsNV, seed, accelerationStructureInfoNV.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInfoNV.instanceCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInfoNV.geometryCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::GeometryNV *, seed, accelerationStructureInfoNV.pGeometries );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AccelerationStructureCreateInfoNV
   {
     using NativeType = VkAccelerationStructureCreateInfoNV;
@@ -2027,6 +2222,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const &
+                            accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoNV.compactedSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV, seed, accelerationStructureCreateInfoNV.info );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AccelerationStructureDeviceAddressInfoKHR
   {
     using NativeType = VkAccelerationStructureDeviceAddressInfoKHR;
@@ -2122,6 +2337,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureDeviceAddressInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const &
+                            accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureDeviceAddressInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureDeviceAddressInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR,
+                             seed,
+                             accelerationStructureDeviceAddressInfoKHR.accelerationStructure );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AccelerationStructureGeometryMotionTrianglesDataNV
   {
     using NativeType = VkAccelerationStructureGeometryMotionTrianglesDataNV;
@@ -2273,6 +2509,28 @@ namespace VULKAN_HPP_NAMESPACE
                             "TransformMatrixKHR is not nothrow_move_constructible!" );
   using TransformMatrixNV = TransformMatrixKHR;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    for ( size_t i = 0; i < 3; ++i )
+    {
+      for ( size_t j = 0; j < 4; ++j )
+      {
+        VULKAN_HPP_HASH_COMBINE( float, seed, transformMatrixKHR.matrix[i][j] );
+      }
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AccelerationStructureInstanceKHR
   {
     using NativeType = VkAccelerationStructureInstanceKHR;
@@ -2398,6 +2656,29 @@ namespace VULKAN_HPP_NAMESPACE
     "AccelerationStructureInstanceKHR is not nothrow_move_constructible!" );
   using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureInstanceKHR.transform );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.instanceCustomIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.mask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset );
+    VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureInstanceKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, accelerationStructureInstanceKHR.accelerationStructureReference );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AccelerationStructureMatrixMotionInstanceNV
   {
     using NativeType = VkAccelerationStructureMatrixMotionInstanceNV;
@@ -2536,6 +2817,32 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV>::value,
     "AccelerationStructureMatrixMotionInstanceNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const &
+                            accelerationStructureMatrixMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureMatrixMotionInstanceNV.transformT0 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureMatrixMotionInstanceNV.transformT1 );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.mask );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset );
+    VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureMatrixMotionInstanceNV.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      uint64_t, seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AccelerationStructureMemoryRequirementsInfoNV
   {
     using NativeType = VkAccelerationStructureMemoryRequirementsInfoNV;
@@ -2644,6 +2951,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureMemoryRequirementsInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const &
+                            accelerationStructureMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureMemoryRequirementsInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureMemoryRequirementsInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV,
+                             seed,
+                             accelerationStructureMemoryRequirementsInfoNV.type );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureNV,
+                             seed,
+                             accelerationStructureMemoryRequirementsInfoNV.accelerationStructure );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AccelerationStructureMotionInfoNV
   {
     using NativeType = VkAccelerationStructureMotionInfoNV;
@@ -2745,6 +3076,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureMotionInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const &
+                            accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureMotionInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureMotionInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMotionInfoNV.maxInstances );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagsNV, seed, accelerationStructureMotionInfoNV.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SRTDataNV
   {
     using NativeType = VkSRTDataNV;
@@ -2948,6 +3299,36 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SRTDataNV>::value,
                             "SRTDataNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SRTDataNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sx );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.a );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.b );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvx );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sy );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.c );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvy );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sz );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvz );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qx );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qy );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qz );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qw );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.tx );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.ty );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.tz );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AccelerationStructureSRTMotionInstanceNV
   {
     using NativeType = VkAccelerationStructureSRTMotionInstanceNV;
@@ -3086,6 +3467,31 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV>::value,
     "AccelerationStructureSRTMotionInstanceNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const &
+                            accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SRTDataNV, seed, accelerationStructureSRTMotionInstanceNV.transformT0 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SRTDataNV, seed, accelerationStructureSRTMotionInstanceNV.transformT1 );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureSRTMotionInstanceNV.mask );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset );
+    VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureSRTMotionInstanceNV.flags );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   union AccelerationStructureMotionInstanceDataNV
   {
     using NativeType = VkAccelerationStructureMotionInstanceDataNV;
@@ -3324,6 +3730,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AccelerationStructureVersionInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const &
+                            accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureVersionInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureVersionInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, accelerationStructureVersionInfoKHR.pVersionData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AcquireNextImageInfoKHR
   {
     using NativeType = VkAcquireNextImageInfoKHR;
@@ -3448,6 +3872,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AcquireNextImageInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, acquireNextImageInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, acquireNextImageInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, acquireNextImageInfoKHR.swapchain );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, acquireNextImageInfoKHR.timeout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, acquireNextImageInfoKHR.semaphore );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, acquireNextImageInfoKHR.fence );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, acquireNextImageInfoKHR.deviceMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AcquireProfilingLockInfoKHR
   {
     using NativeType = VkAcquireProfilingLockInfoKHR;
@@ -3544,6 +3990,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = AcquireProfilingLockInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, acquireProfilingLockInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, acquireProfilingLockInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR, seed, acquireProfilingLockInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, acquireProfilingLockInfoKHR.timeout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AllocationCallbacks
   {
     using NativeType = VkAllocationCallbacks;
@@ -3661,6 +4127,27 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AllocationCallbacks>::value,
                             "AllocationCallbacks is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( void *, seed, allocationCallbacks.pUserData );
+    VULKAN_HPP_HASH_COMBINE( PFN_vkAllocationFunction, seed, allocationCallbacks.pfnAllocation );
+    VULKAN_HPP_HASH_COMBINE( PFN_vkReallocationFunction, seed, allocationCallbacks.pfnReallocation );
+    VULKAN_HPP_HASH_COMBINE( PFN_vkFreeFunction, seed, allocationCallbacks.pfnFree );
+    VULKAN_HPP_HASH_COMBINE( PFN_vkInternalAllocationNotification, seed, allocationCallbacks.pfnInternalAllocation );
+    VULKAN_HPP_HASH_COMBINE( PFN_vkInternalFreeNotification, seed, allocationCallbacks.pfnInternalFree );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ComponentMapping
   {
     using NativeType = VkComponentMapping;
@@ -3756,6 +4243,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ComponentMapping>::value,
                             "ComponentMapping is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ComponentMapping>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.r );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.g );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.b );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.a );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
   struct AndroidHardwareBufferFormatProperties2ANDROID
   {
@@ -3864,6 +4369,45 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = AndroidHardwareBufferFormatProperties2ANDROID;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const &
+                            androidHardwareBufferFormatProperties2ANDROID ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferFormatProperties2ANDROID.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferFormatProperties2ANDROID.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, androidHardwareBufferFormatProperties2ANDROID.format );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR,
+                             seed,
+                             androidHardwareBufferFormatProperties2ANDROID.formatFeatures );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping,
+                             seed,
+                             androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion,
+                             seed,
+                             androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrRange,
+                             seed,
+                             androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ChromaLocation,
+                             seed,
+                             androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ChromaLocation,
+                             seed,
+                             androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
@@ -3974,6 +4518,41 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = AndroidHardwareBufferFormatPropertiesANDROID;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const &
+                            androidHardwareBufferFormatPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferFormatPropertiesANDROID.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferFormatPropertiesANDROID.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, androidHardwareBufferFormatPropertiesANDROID.format );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping,
+                             seed,
+                             androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion,
+                             seed,
+                             androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
@@ -4057,6 +4636,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = AndroidHardwareBufferPropertiesANDROID;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const &
+                            androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferPropertiesANDROID.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferPropertiesANDROID.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, androidHardwareBufferPropertiesANDROID.allocationSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
@@ -4135,6 +4735,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = AndroidHardwareBufferUsageANDROID;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const &
+                            androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferUsageANDROID.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferUsageANDROID.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
@@ -4234,6 +4853,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = AndroidSurfaceCreateInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidSurfaceCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, androidSurfaceCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR, seed, androidSurfaceCreateInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( struct ANativeWindow *, seed, androidSurfaceCreateInfoKHR.window );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct ApplicationInfo
@@ -4357,6 +4997,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ApplicationInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ApplicationInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, applicationInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, applicationInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( const char *, seed, applicationInfo.pApplicationName );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.applicationVersion );
+    VULKAN_HPP_HASH_COMBINE( const char *, seed, applicationInfo.pEngineName );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.engineVersion );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.apiVersion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AttachmentDescription
   {
     using NativeType = VkAttachmentDescription;
@@ -4509,6 +5170,30 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentDescription>::value,
                             "AttachmentDescription is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentDescription>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags, seed, attachmentDescription.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, attachmentDescription.format );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentDescription.samples );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription.loadOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription.storeOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription.stencilLoadOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription.stencilStoreOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription.initialLayout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription.finalLayout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AttachmentDescription2
   {
     using NativeType = VkAttachmentDescription2;
@@ -4680,6 +5365,32 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using AttachmentDescription2KHR = AttachmentDescription2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentDescription2.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentDescription2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags, seed, attachmentDescription2.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, attachmentDescription2.format );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentDescription2.samples );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription2.loadOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription2.storeOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription2.stencilLoadOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription2.stencilStoreOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription2.initialLayout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription2.finalLayout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AttachmentDescriptionStencilLayout
   {
     using NativeType = VkAttachmentDescriptionStencilLayout;
@@ -4784,6 +5495,27 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const &
+                            attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentDescriptionStencilLayout.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, attachmentDescriptionStencilLayout.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescriptionStencilLayout.stencilInitialLayout );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescriptionStencilLayout.stencilFinalLayout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AttachmentReference
   {
     using NativeType = VkAttachmentReference;
@@ -4861,6 +5593,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentReference>::value,
                             "AttachmentReference is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentReference>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentReference.attachment );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReference.layout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AttachmentReference2
   {
     using NativeType = VkAttachmentReference2;
@@ -4967,6 +5716,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using AttachmentReference2KHR = AttachmentReference2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentReference2>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentReference2.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentReference2.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentReference2.attachment );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReference2.layout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, attachmentReference2.aspectMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AttachmentReferenceStencilLayout
   {
     using NativeType = VkAttachmentReferenceStencilLayout;
@@ -5058,6 +5827,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentReferenceStencilLayout.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, attachmentReferenceStencilLayout.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReferenceStencilLayout.stencilLayout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AttachmentSampleCountInfoAMD
   {
     using NativeType = VkAttachmentSampleCountInfoAMD;
@@ -5193,6 +5981,28 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentSampleCountInfoAMD.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentSampleCountInfoAMD.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentSampleCountInfoAMD.colorAttachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SampleCountFlagBits *, seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct Extent2D
   {
     using NativeType = VkExtent2D;
@@ -5265,6 +6075,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Extent2D>::value,
                             "Extent2D is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::Extent2D>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent2D.width );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent2D.height );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SampleLocationEXT
   {
     using NativeType = VkSampleLocationEXT;
@@ -5339,6 +6165,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SampleLocationEXT>::value,
                             "SampleLocationEXT is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( float, seed, sampleLocationEXT.x );
+    VULKAN_HPP_HASH_COMBINE( float, seed, sampleLocationEXT.y );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SampleLocationsInfoEXT
   {
     using NativeType = VkSampleLocationsInfoEXT;
@@ -5483,6 +6325,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SampleLocationsInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sampleLocationsInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, sampleLocationsInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, sampleLocationsInfoEXT.sampleLocationsPerPixel );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, sampleLocationsInfoEXT.sampleLocationGridSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sampleLocationsInfoEXT.sampleLocationsCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SampleLocationEXT *, seed, sampleLocationsInfoEXT.pSampleLocations );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct AttachmentSampleLocationsEXT
   {
     using NativeType = VkAttachmentSampleLocationsEXT;
@@ -5564,6 +6429,24 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT>::value,
     "AttachmentSampleLocationsEXT is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentSampleLocationsEXT.attachmentIndex );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT, seed, attachmentSampleLocationsEXT.sampleLocationsInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BaseInStructure
   {
     using NativeType = VkBaseInStructure;
@@ -5632,6 +6515,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BaseInStructure>::value,
                             "BaseInStructure is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BaseInStructure>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, baseInStructure.sType );
+    VULKAN_HPP_HASH_COMBINE( const struct VULKAN_HPP_NAMESPACE::BaseInStructure *, seed, baseInStructure.pNext );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BaseOutStructure
   {
     using NativeType = VkBaseOutStructure;
@@ -5700,6 +6599,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BaseOutStructure>::value,
                             "BaseOutStructure is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BaseOutStructure>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, baseOutStructure.sType );
+    VULKAN_HPP_HASH_COMBINE( struct VULKAN_HPP_NAMESPACE::BaseOutStructure *, seed, baseOutStructure.pNext );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BindAccelerationStructureMemoryInfoNV
   {
     using NativeType = VkBindAccelerationStructureMemoryInfoNV;
@@ -5859,6 +6774,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BindAccelerationStructureMemoryInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const &
+                            bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindAccelerationStructureMemoryInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindAccelerationStructureMemoryInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureNV,
+                             seed,
+                             bindAccelerationStructureMemoryInfoNV.accelerationStructure );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindAccelerationStructureMemoryInfoNV.memory );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindAccelerationStructureMemoryInfoNV.memoryOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BindBufferMemoryDeviceGroupInfo
   {
     using NativeType = VkBindBufferMemoryDeviceGroupInfo;
@@ -5976,6 +6916,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindBufferMemoryDeviceGroupInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindBufferMemoryDeviceGroupInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BindBufferMemoryInfo
   {
     using NativeType = VkBindBufferMemoryInfo;
@@ -6081,6 +7041,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindBufferMemoryInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindBufferMemoryInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bindBufferMemoryInfo.buffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindBufferMemoryInfo.memory );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindBufferMemoryInfo.memoryOffset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct Offset2D
   {
     using NativeType = VkOffset2D;
@@ -6153,6 +7133,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Offset2D>::value,
                             "Offset2D is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::Offset2D>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset2D.x );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset2D.y );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct Rect2D
   {
     using NativeType = VkRect2D;
@@ -6226,6 +7222,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Rect2D>::value,
                             "Rect2D is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::Rect2D>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, rect2D.offset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, rect2D.extent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BindImageMemoryDeviceGroupInfo
   {
     using NativeType = VkBindImageMemoryDeviceGroupInfo;
@@ -6382,6 +7394,28 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemoryDeviceGroupInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemoryDeviceGroupInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::Rect2D *, seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BindImageMemoryInfo
   {
     using NativeType = VkBindImageMemoryInfo;
@@ -6487,6 +7521,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BindImageMemoryInfoKHR = BindImageMemoryInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemoryInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemoryInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, bindImageMemoryInfo.image );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindImageMemoryInfo.memory );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindImageMemoryInfo.memoryOffset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BindImageMemorySwapchainInfoKHR
   {
     using NativeType = VkBindImageMemorySwapchainInfoKHR;
@@ -6585,6 +7639,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BindImageMemorySwapchainInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemorySwapchainInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemorySwapchainInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, bindImageMemorySwapchainInfoKHR.swapchain );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemorySwapchainInfoKHR.imageIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BindImagePlaneMemoryInfo
   {
     using NativeType = VkBindImagePlaneMemoryInfo;
@@ -6673,6 +7747,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImagePlaneMemoryInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImagePlaneMemoryInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, bindImagePlaneMemoryInfo.planeAspect );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BindIndexBufferIndirectCommandNV
   {
     using NativeType = VkBindIndexBufferIndirectCommandNV;
@@ -6764,6 +7856,26 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV>::value,
     "BindIndexBufferIndirectCommandNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bindIndexBufferIndirectCommandNV.bufferAddress );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindIndexBufferIndirectCommandNV.size );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndexType, seed, bindIndexBufferIndirectCommandNV.indexType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BindShaderGroupIndirectCommandNV
   {
     using NativeType = VkBindShaderGroupIndirectCommandNV;
@@ -6834,6 +7946,23 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV>::value,
     "BindShaderGroupIndirectCommandNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindShaderGroupIndirectCommandNV.groupIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SparseMemoryBind
   {
     using NativeType = VkSparseMemoryBind;
@@ -6941,6 +8070,25 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseMemoryBind>::value,
                             "SparseMemoryBind is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.resourceOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.size );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, sparseMemoryBind.memory );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.memoryOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags, seed, sparseMemoryBind.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SparseBufferMemoryBindInfo
   {
     using NativeType = VkSparseBufferMemoryBindInfo;
@@ -7049,6 +8197,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo>::value,
                             "SparseBufferMemoryBindInfo is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, sparseBufferMemoryBindInfo.buffer );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseBufferMemoryBindInfo.bindCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SparseMemoryBind *, seed, sparseBufferMemoryBindInfo.pBinds );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SparseImageOpaqueMemoryBindInfo
   {
     using NativeType = VkSparseImageOpaqueMemoryBindInfo;
@@ -7159,6 +8325,26 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo>::value,
     "SparseImageOpaqueMemoryBindInfo is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, sparseImageOpaqueMemoryBindInfo.image );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageOpaqueMemoryBindInfo.bindCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SparseMemoryBind *, seed, sparseImageOpaqueMemoryBindInfo.pBinds );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageSubresource
   {
     using NativeType = VkImageSubresource;
@@ -7244,6 +8430,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageSubresource>::value,
                             "ImageSubresource is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageSubresource>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresource.aspectMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresource.mipLevel );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresource.arrayLayer );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct Offset3D
   {
     using NativeType = VkOffset3D;
@@ -7326,6 +8529,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Offset3D>::value,
                             "Offset3D is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::Offset3D>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.x );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.y );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.z );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct Extent3D
   {
     using NativeType = VkExtent3D;
@@ -7411,6 +8631,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Extent3D>::value,
                             "Extent3D is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::Extent3D>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.width );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.height );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.depth );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SparseImageMemoryBind
   {
     using NativeType = VkSparseImageMemoryBind;
@@ -7530,6 +8767,27 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind>::value,
                             "SparseImageMemoryBind is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresource, seed, sparseImageMemoryBind.subresource );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, sparseImageMemoryBind.offset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, sparseImageMemoryBind.extent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, sparseImageMemoryBind.memory );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryBind.memoryOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags, seed, sparseImageMemoryBind.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SparseImageMemoryBindInfo
   {
     using NativeType = VkSparseImageMemoryBindInfo;
@@ -7638,6 +8896,25 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo>::value,
                             "SparseImageMemoryBindInfo is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, sparseImageMemoryBindInfo.image );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageMemoryBindInfo.bindCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind *, seed, sparseImageMemoryBindInfo.pBinds );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BindSparseInfo
   {
     using NativeType = VkBindSparseInfo;
@@ -7894,6 +9171,35 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BindSparseInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BindSparseInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindSparseInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bindSparseInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.waitSemaphoreCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, bindSparseInfo.pWaitSemaphores );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.bufferBindCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo *, seed, bindSparseInfo.pBufferBinds );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.imageOpaqueBindCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo *, seed, bindSparseInfo.pImageOpaqueBinds );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.imageBindCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo *, seed, bindSparseInfo.pImageBinds );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.signalSemaphoreCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, bindSparseInfo.pSignalSemaphores );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BindVertexBufferIndirectCommandNV
   {
     using NativeType = VkBindVertexBufferIndirectCommandNV;
@@ -7983,6 +9289,25 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV>::value,
     "BindVertexBufferIndirectCommandNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const &
+                            bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bindVertexBufferIndirectCommandNV.bufferAddress );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindVertexBufferIndirectCommandNV.size );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindVertexBufferIndirectCommandNV.stride );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageSubresourceLayers
   {
     using NativeType = VkImageSubresourceLayers;
@@ -8079,6 +9404,25 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers>::value,
                             "ImageSubresourceLayers is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresourceLayers.aspectMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.mipLevel );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.baseArrayLayer );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.layerCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageBlit2KHR
   {
     using NativeType = VkImageBlit2KHR;
@@ -8196,6 +9540,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageBlit2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageBlit2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2KHR const & imageBlit2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageBlit2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageBlit2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit2KHR.srcSubresource );
+    for ( size_t i = 0; i < 2; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit2KHR.srcOffsets[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit2KHR.dstSubresource );
+    for ( size_t i = 0; i < 2; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit2KHR.dstOffsets[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BlitImageInfo2KHR
   {
     using NativeType = VkBlitImageInfo2KHR;
@@ -8369,6 +9739,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BlitImageInfo2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR const & blitImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, blitImageInfo2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, blitImageInfo2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, blitImageInfo2KHR.srcImage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, blitImageInfo2KHR.srcImageLayout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, blitImageInfo2KHR.dstImage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, blitImageInfo2KHR.dstImageLayout );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, blitImageInfo2KHR.regionCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageBlit2KHR *, seed, blitImageInfo2KHR.pRegions );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, blitImageInfo2KHR.filter );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_FUCHSIA )
   struct BufferCollectionBufferCreateInfoFUCHSIA
   {
@@ -8473,6 +9866,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferCollectionBufferCreateInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const &
+                            bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionBufferCreateInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, bufferCollectionBufferCreateInfoFUCHSIA.collection );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionBufferCreateInfoFUCHSIA.index );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -8611,6 +10025,29 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferCollectionConstraintsInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const &
+                            bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionConstraintsInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionConstraintsInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -8703,6 +10140,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferCollectionCreateInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const &
+                            bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionCreateInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionCreateInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, bufferCollectionCreateInfoFUCHSIA.collectionToken );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -8808,6 +10264,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferCollectionImageCreateInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const &
+                            bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionImageCreateInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionImageCreateInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, bufferCollectionImageCreateInfoFUCHSIA.collection );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionImageCreateInfoFUCHSIA.index );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -8894,6 +10371,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SysmemColorSpaceFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sysmemColorSpaceFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, sysmemColorSpaceFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sysmemColorSpaceFUCHSIA.colorSpace );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -9096,6 +10592,43 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferCollectionPropertiesFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const &
+                            bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionPropertiesFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, bufferCollectionPropertiesFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.bufferCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, bufferCollectionPropertiesFUCHSIA.formatFeatures );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA, seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping,
+                             seed,
+                             bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion, seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct BufferCreateInfo
@@ -9260,6 +10793,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateFlags, seed, bufferCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCreateInfo.size );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferUsageFlags, seed, bufferCreateInfo.usage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, bufferCreateInfo.sharingMode );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCreateInfo.queueFamilyIndexCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bufferCreateInfo.pQueueFamilyIndices );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_FUCHSIA )
   struct BufferConstraintsInfoFUCHSIA
   {
@@ -9372,6 +10927,30 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = BufferConstraintsInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferConstraintsInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferConstraintsInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateInfo, seed, bufferConstraintsInfoFUCHSIA.createInfo );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA,
+                             seed,
+                             bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct BufferCopy
@@ -9458,6 +11037,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferCopy>::value,
                             "BufferCopy is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferCopy>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.srcOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.dstOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.size );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BufferCopy2KHR
   {
     using NativeType = VkBufferCopy2KHR;
@@ -9562,6 +11158,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferCopy2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferCopy2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2KHR const & bufferCopy2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCopy2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCopy2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.srcOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.dstOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.size );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BufferDeviceAddressCreateInfoEXT
   {
     using NativeType = VkBufferDeviceAddressCreateInfoEXT;
@@ -9651,6 +11266,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferDeviceAddressCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferDeviceAddressCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferDeviceAddressCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bufferDeviceAddressCreateInfoEXT.deviceAddress );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BufferDeviceAddressInfo
   {
     using NativeType = VkBufferDeviceAddressInfo;
@@ -9738,6 +11373,24 @@ namespace VULKAN_HPP_NAMESPACE
   using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
   using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferDeviceAddressInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferDeviceAddressInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferDeviceAddressInfo.buffer );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BufferImageCopy
   {
     using NativeType = VkBufferImageCopy;
@@ -9855,6 +11508,26 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferImageCopy>::value,
                             "BufferImageCopy is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferImageCopy>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferImageCopy.bufferOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy.bufferRowLength );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy.bufferImageHeight );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, bufferImageCopy.imageSubresource );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, bufferImageCopy.imageOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, bufferImageCopy.imageExtent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BufferImageCopy2KHR
   {
     using NativeType = VkBufferImageCopy2KHR;
@@ -9991,6 +11664,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferImageCopy2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR const & bufferImageCopy2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferImageCopy2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferImageCopy2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferImageCopy2KHR.bufferOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy2KHR.bufferRowLength );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy2KHR.bufferImageHeight );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, bufferImageCopy2KHR.imageSubresource );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, bufferImageCopy2KHR.imageOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, bufferImageCopy2KHR.imageExtent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BufferMemoryBarrier
   {
     using NativeType = VkBufferMemoryBarrier;
@@ -10136,6 +11832,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferMemoryBarrier;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryBarrier.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryBarrier.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, bufferMemoryBarrier.srcAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, bufferMemoryBarrier.dstAccessMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier.srcQueueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier.dstQueueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryBarrier.buffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier.offset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier.size );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BufferMemoryBarrier2KHR
   {
     using NativeType = VkBufferMemoryBarrier2KHR;
@@ -10305,6 +12025,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferMemoryBarrier2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR const & bufferMemoryBarrier2KHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryBarrier2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryBarrier2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, bufferMemoryBarrier2KHR.srcStageMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, bufferMemoryBarrier2KHR.srcAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, bufferMemoryBarrier2KHR.dstStageMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, bufferMemoryBarrier2KHR.dstAccessMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier2KHR.srcQueueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier2KHR.dstQueueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryBarrier2KHR.buffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier2KHR.offset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier2KHR.size );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BufferMemoryRequirementsInfo2
   {
     using NativeType = VkBufferMemoryRequirementsInfo2;
@@ -10394,6 +12140,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryRequirementsInfo2.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryRequirementsInfo2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryRequirementsInfo2.buffer );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BufferOpaqueCaptureAddressCreateInfo
   {
     using NativeType = VkBufferOpaqueCaptureAddressCreateInfo;
@@ -10485,6 +12249,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const &
+                            bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferOpaqueCaptureAddressCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferOpaqueCaptureAddressCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct BufferViewCreateInfo
   {
     using NativeType = VkBufferViewCreateInfo;
@@ -10609,6 +12391,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = BufferViewCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferViewCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferViewCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferViewCreateFlags, seed, bufferViewCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferViewCreateInfo.buffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, bufferViewCreateInfo.format );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferViewCreateInfo.offset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferViewCreateInfo.range );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CalibratedTimestampInfoEXT
   {
     using NativeType = VkCalibratedTimestampInfoEXT;
@@ -10697,6 +12501,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CalibratedTimestampInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT const & calibratedTimestampInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, calibratedTimestampInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, calibratedTimestampInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::TimeDomainEXT, seed, calibratedTimestampInfoEXT.timeDomain );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CheckpointData2NV
   {
     using NativeType = VkCheckpointData2NV;
@@ -10770,6 +12592,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CheckpointData2NV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, checkpointData2NV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointData2NV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, checkpointData2NV.stage );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointData2NV.pCheckpointMarker );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CheckpointDataNV
   {
     using NativeType = VkCheckpointDataNV;
@@ -10844,6 +12684,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CheckpointDataNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, checkpointDataNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointDataNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits, seed, checkpointDataNV.stage );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointDataNV.pCheckpointMarker );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   union ClearColorValue
   {
     using NativeType = VkClearColorValue;
@@ -10966,6 +12824,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue>::value,
                             "ClearDepthStencilValue is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( float, seed, clearDepthStencilValue.depth );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearDepthStencilValue.stencil );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   union ClearValue
   {
     using NativeType = VkClearValue;
@@ -11168,6 +13043,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClearRect>::value,
                             "ClearRect is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ClearRect>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, clearRect.rect );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearRect.baseArrayLayer );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearRect.layerCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CoarseSampleLocationNV
   {
     using NativeType = VkCoarseSampleLocationNV;
@@ -11252,6 +13144,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV>::value,
                             "CoarseSampleLocationNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.pixelX );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.pixelY );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.sample );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CoarseSampleOrderCustomNV
   {
     using NativeType = VkCoarseSampleOrderCustomNV;
@@ -11378,6 +13288,27 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV>::value,
                             "CoarseSampleOrderCustomNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV, seed, coarseSampleOrderCustomNV.shadingRate );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleOrderCustomNV.sampleCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleOrderCustomNV.sampleLocationCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV *, seed, coarseSampleOrderCustomNV.pSampleLocations );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CommandBufferAllocateInfo
   {
     using NativeType = VkCommandBufferAllocateInfo;
@@ -11486,6 +13417,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferAllocateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferAllocateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferAllocateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandPool, seed, commandBufferAllocateInfo.commandPool );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBufferLevel, seed, commandBufferAllocateInfo.level );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferAllocateInfo.commandBufferCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CommandBufferInheritanceInfo
   {
     using NativeType = VkCommandBufferInheritanceInfo;
@@ -11626,6 +13577,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferInheritanceInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, commandBufferInheritanceInfo.renderPass );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceInfo.subpass );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Framebuffer, seed, commandBufferInheritanceInfo.framebuffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, commandBufferInheritanceInfo.occlusionQueryEnable );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryControlFlags, seed, commandBufferInheritanceInfo.queryFlags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags, seed, commandBufferInheritanceInfo.pipelineStatistics );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CommandBufferBeginInfo
   {
     using NativeType = VkCommandBufferBeginInfo;
@@ -11723,6 +13698,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferBeginInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferBeginInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferBeginInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags, seed, commandBufferBeginInfo.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo *, seed, commandBufferBeginInfo.pInheritanceInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CommandBufferInheritanceConditionalRenderingInfoEXT
   {
     using NativeType = VkCommandBufferInheritanceConditionalRenderingInfoEXT;
@@ -11820,6 +13815,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferInheritanceConditionalRenderingInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const &
+                            commandBufferInheritanceConditionalRenderingInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CommandBufferInheritanceRenderPassTransformInfoQCOM
   {
     using NativeType = VkCommandBufferInheritanceRenderPassTransformInfoQCOM;
@@ -11929,6 +13945,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const &
+                            commandBufferInheritanceRenderPassTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR,
+                             seed,
+                             commandBufferInheritanceRenderPassTransformInfoQCOM.transform );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Rect2D, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CommandBufferInheritanceRenderingInfoKHR
   {
     using NativeType = VkCommandBufferInheritanceRenderingInfoKHR;
@@ -12119,6 +14158,36 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferInheritanceRenderingInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfoKHR const &
+                            commandBufferInheritanceRenderingInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceRenderingInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceRenderingInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::RenderingFlagsKHR, seed, commandBufferInheritanceRenderingInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceRenderingInfoKHR.viewMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceRenderingInfoKHR.colorAttachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::Format *, seed, commandBufferInheritanceRenderingInfoKHR.pColorAttachmentFormats );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Format, seed, commandBufferInheritanceRenderingInfoKHR.depthAttachmentFormat );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Format, seed, commandBufferInheritanceRenderingInfoKHR.stencilAttachmentFormat );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, commandBufferInheritanceRenderingInfoKHR.rasterizationSamples );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct Viewport
   {
     using NativeType = VkViewport;
@@ -12229,6 +14298,26 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Viewport>::value,
                             "Viewport is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::Viewport>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.x );
+    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.y );
+    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.width );
+    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.height );
+    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.minDepth );
+    VULKAN_HPP_HASH_COMBINE( float, seed, viewport.maxDepth );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CommandBufferInheritanceViewportScissorInfoNV
   {
     using NativeType = VkCommandBufferInheritanceViewportScissorInfoNV;
@@ -12345,6 +14434,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferInheritanceViewportScissorInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const &
+                            commandBufferInheritanceViewportScissorInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceViewportScissorInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceViewportScissorInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::Viewport *, seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CommandBufferSubmitInfoKHR
   {
     using NativeType = VkCommandBufferSubmitInfoKHR;
@@ -12441,6 +14553,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandBufferSubmitInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR const & commandBufferSubmitInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferSubmitInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferSubmitInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBuffer, seed, commandBufferSubmitInfoKHR.commandBuffer );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferSubmitInfoKHR.deviceMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CommandPoolCreateInfo
   {
     using NativeType = VkCommandPoolCreateInfo;
@@ -12536,6 +14667,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CommandPoolCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandPoolCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, commandPoolCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags, seed, commandPoolCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandPoolCreateInfo.queueFamilyIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SpecializationMapEntry
   {
     using NativeType = VkSpecializationMapEntry;
@@ -12620,6 +14770,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SpecializationMapEntry>::value,
                             "SpecializationMapEntry is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationMapEntry.constantID );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationMapEntry.offset );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, specializationMapEntry.size );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SpecializationInfo
   {
     using NativeType = VkSpecializationInfo;
@@ -12749,6 +14917,26 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SpecializationInfo>::value,
                             "SpecializationInfo is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SpecializationInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationInfo.mapEntryCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SpecializationMapEntry *, seed, specializationInfo.pMapEntries );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, specializationInfo.dataSize );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, specializationInfo.pData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineShaderStageCreateInfo
   {
     using NativeType = VkPipelineShaderStageCreateInfo;
@@ -12878,6 +15066,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineShaderStageCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineShaderStageCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineShaderStageCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags, seed, pipelineShaderStageCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits, seed, pipelineShaderStageCreateInfo.stage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderModule, seed, pipelineShaderStageCreateInfo.module );
+    VULKAN_HPP_HASH_COMBINE( const char *, seed, pipelineShaderStageCreateInfo.pName );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SpecializationInfo *, seed, pipelineShaderStageCreateInfo.pSpecializationInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ComputePipelineCreateInfo
   {
     using NativeType = VkComputePipelineCreateInfo;
@@ -13006,6 +15218,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ComputePipelineCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, computePipelineCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, computePipelineCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, computePipelineCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo, seed, computePipelineCreateInfo.stage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, computePipelineCreateInfo.layout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, computePipelineCreateInfo.basePipelineHandle );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, computePipelineCreateInfo.basePipelineIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ConditionalRenderingBeginInfoEXT
   {
     using NativeType = VkConditionalRenderingBeginInfoEXT;
@@ -13116,6 +15351,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ConditionalRenderingBeginInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, conditionalRenderingBeginInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, conditionalRenderingBeginInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, conditionalRenderingBeginInfoEXT.buffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, conditionalRenderingBeginInfoEXT.offset );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT, seed, conditionalRenderingBeginInfoEXT.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ConformanceVersion
   {
     using NativeType = VkConformanceVersion;
@@ -13210,6 +15467,25 @@ namespace VULKAN_HPP_NAMESPACE
                             "ConformanceVersion is not nothrow_move_constructible!" );
   using ConformanceVersionKHR = ConformanceVersion;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ConformanceVersion>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.major );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.minor );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.subminor );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.patch );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CooperativeMatrixPropertiesNV
   {
     using NativeType = VkCooperativeMatrixPropertiesNV;
@@ -13368,6 +15644,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CooperativeMatrixPropertiesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cooperativeMatrixPropertiesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, cooperativeMatrixPropertiesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.MSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.NSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.KSize );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.AType );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.BType );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.CType );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.DType );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ScopeNV, seed, cooperativeMatrixPropertiesNV.scope );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CopyAccelerationStructureInfoKHR
   {
     using NativeType = VkCopyAccelerationStructureInfoKHR;
@@ -13480,6 +15781,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyAccelerationStructureInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyAccelerationStructureInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyAccelerationStructureInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, seed, copyAccelerationStructureInfoKHR.src );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, seed, copyAccelerationStructureInfoKHR.dst );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR, seed, copyAccelerationStructureInfoKHR.mode );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CopyAccelerationStructureToMemoryInfoKHR
   {
     using NativeType = VkCopyAccelerationStructureToMemoryInfoKHR;
@@ -13721,6 +16046,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyBufferInfo2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR const & copyBufferInfo2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyBufferInfo2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyBufferInfo2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferInfo2KHR.srcBuffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferInfo2KHR.dstBuffer );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyBufferInfo2KHR.regionCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::BufferCopy2KHR *, seed, copyBufferInfo2KHR.pRegions );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CopyBufferToImageInfo2KHR
   {
     using NativeType = VkCopyBufferToImageInfo2KHR;
@@ -13874,6 +16220,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyBufferToImageInfo2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR const & copyBufferToImageInfo2KHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyBufferToImageInfo2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyBufferToImageInfo2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferToImageInfo2KHR.srcBuffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyBufferToImageInfo2KHR.dstImage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyBufferToImageInfo2KHR.dstImageLayout );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyBufferToImageInfo2KHR.regionCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR *, seed, copyBufferToImageInfo2KHR.pRegions );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CopyCommandTransformInfoQCOM
   {
     using NativeType = VkCopyCommandTransformInfoQCOM;
@@ -13964,6 +16333,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyCommandTransformInfoQCOM;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyCommandTransformInfoQCOM.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyCommandTransformInfoQCOM.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, copyCommandTransformInfoQCOM.transform );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CopyDescriptorSet
   {
     using NativeType = VkCopyDescriptorSet;
@@ -14106,6 +16494,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyDescriptorSet;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyDescriptorSet.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyDescriptorSet.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, copyDescriptorSet.srcSet );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.srcBinding );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.srcArrayElement );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, copyDescriptorSet.dstSet );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.dstBinding );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.dstArrayElement );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.descriptorCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageCopy2KHR
   {
     using NativeType = VkImageCopy2KHR;
@@ -14232,6 +16643,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageCopy2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageCopy2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2KHR const & imageCopy2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageCopy2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageCopy2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy2KHR.srcSubresource );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy2KHR.srcOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy2KHR.dstSubresource );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy2KHR.dstOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCopy2KHR.extent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CopyImageInfo2KHR
   {
     using NativeType = VkCopyImageInfo2KHR;
@@ -14394,6 +16826,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyImageInfo2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR const & copyImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyImageInfo2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyImageInfo2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageInfo2KHR.srcImage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageInfo2KHR.srcImageLayout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageInfo2KHR.dstImage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageInfo2KHR.dstImageLayout );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyImageInfo2KHR.regionCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageCopy2KHR *, seed, copyImageInfo2KHR.pRegions );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CopyImageToBufferInfo2KHR
   {
     using NativeType = VkCopyImageToBufferInfo2KHR;
@@ -14547,6 +17001,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CopyImageToBufferInfo2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR const & copyImageToBufferInfo2KHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyImageToBufferInfo2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, copyImageToBufferInfo2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageToBufferInfo2KHR.srcImage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageToBufferInfo2KHR.srcImageLayout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyImageToBufferInfo2KHR.dstBuffer );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyImageToBufferInfo2KHR.regionCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR *, seed, copyImageToBufferInfo2KHR.pRegions );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CopyMemoryToAccelerationStructureInfoKHR
   {
     using NativeType = VkCopyMemoryToAccelerationStructureInfoKHR;
@@ -14744,6 +17221,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CuFunctionCreateInfoNVX;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuFunctionCreateInfoNVX.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, cuFunctionCreateInfoNVX.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CuModuleNVX, seed, cuFunctionCreateInfoNVX.module );
+    VULKAN_HPP_HASH_COMBINE( const char *, seed, cuFunctionCreateInfoNVX.pName );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CuLaunchInfoNVX
   {
     using NativeType = VkCuLaunchInfoNVX;
@@ -14977,6 +17473,34 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CuLaunchInfoNVX;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuLaunchInfoNVX.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, cuLaunchInfoNVX.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CuFunctionNVX, seed, cuLaunchInfoNVX.function );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimX );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimY );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimZ );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimX );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimY );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimZ );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.sharedMemBytes );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, cuLaunchInfoNVX.paramCount );
+    VULKAN_HPP_HASH_COMBINE( const void * const *, seed, cuLaunchInfoNVX.pParams );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, cuLaunchInfoNVX.extraCount );
+    VULKAN_HPP_HASH_COMBINE( const void * const *, seed, cuLaunchInfoNVX.pExtras );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct CuModuleCreateInfoNVX
   {
     using NativeType = VkCuModuleCreateInfoNVX;
@@ -15086,6 +17610,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = CuModuleCreateInfoNVX;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuModuleCreateInfoNVX.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, cuModuleCreateInfoNVX.pNext );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, cuModuleCreateInfoNVX.dataSize );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, cuModuleCreateInfoNVX.pData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct D3D12FenceSubmitInfoKHR
   {
@@ -15236,6 +17779,28 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = D3D12FenceSubmitInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, d3D12FenceSubmitInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, d3D12FenceSubmitInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount );
+    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount );
+    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct DebugMarkerMarkerInfoEXT
@@ -15333,6 +17898,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugMarkerMarkerInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerMarkerInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerMarkerInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugMarkerMarkerInfoEXT.pMarkerName );
+    for ( size_t i = 0; i < 4; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( float, seed, debugMarkerMarkerInfoEXT.color[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DebugMarkerObjectNameInfoEXT
   {
     using NativeType = VkDebugMarkerObjectNameInfoEXT;
@@ -15442,6 +18029,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugMarkerObjectNameInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerObjectNameInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectNameInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, seed, debugMarkerObjectNameInfoEXT.objectType );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectNameInfoEXT.object );
+    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugMarkerObjectNameInfoEXT.pObjectName );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DebugMarkerObjectTagInfoEXT
   {
     using NativeType = VkDebugMarkerObjectTagInfoEXT;
@@ -15594,6 +18202,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugMarkerObjectTagInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerObjectTagInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectTagInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, seed, debugMarkerObjectTagInfoEXT.objectType );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectTagInfoEXT.object );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectTagInfoEXT.tagName );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, debugMarkerObjectTagInfoEXT.tagSize );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectTagInfoEXT.pTag );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DebugReportCallbackCreateInfoEXT
   {
     using NativeType = VkDebugReportCallbackCreateInfoEXT;
@@ -15702,6 +18333,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugReportCallbackCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugReportCallbackCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugReportCallbackCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT, seed, debugReportCallbackCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( PFN_vkDebugReportCallbackEXT, seed, debugReportCallbackCreateInfoEXT.pfnCallback );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, debugReportCallbackCreateInfoEXT.pUserData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DebugUtilsLabelEXT
   {
     using NativeType = VkDebugUtilsLabelEXT;
@@ -15795,6 +18447,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugUtilsLabelEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsLabelEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsLabelEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsLabelEXT.pLabelName );
+    for ( size_t i = 0; i < 4; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( float, seed, debugUtilsLabelEXT.color[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DebugUtilsObjectNameInfoEXT
   {
     using NativeType = VkDebugUtilsObjectNameInfoEXT;
@@ -15903,6 +18577,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugUtilsObjectNameInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsObjectNameInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectNameInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, debugUtilsObjectNameInfoEXT.objectType );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectNameInfoEXT.objectHandle );
+    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsObjectNameInfoEXT.pObjectName );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DebugUtilsMessengerCallbackDataEXT
   {
     using NativeType = VkDebugUtilsMessengerCallbackDataEXT;
@@ -16147,6 +18841,37 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugUtilsMessengerCallbackDataEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const &
+                            debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsMessengerCallbackDataEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsMessengerCallbackDataEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT, seed, debugUtilsMessengerCallbackDataEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsMessengerCallbackDataEXT.pMessageIdName );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber );
+    VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsMessengerCallbackDataEXT.pMessage );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *, seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *, seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.objectCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT *, seed, debugUtilsMessengerCallbackDataEXT.pObjects );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DebugUtilsMessengerCreateInfoEXT
   {
     using NativeType = VkDebugUtilsMessengerCreateInfoEXT;
@@ -16277,6 +19002,33 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugUtilsMessengerCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsMessengerCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsMessengerCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.messageSeverity );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.messageType );
+    VULKAN_HPP_HASH_COMBINE(
+      PFN_vkDebugUtilsMessengerCallbackEXT, seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, debugUtilsMessengerCreateInfoEXT.pUserData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DebugUtilsObjectTagInfoEXT
   {
     using NativeType = VkDebugUtilsObjectTagInfoEXT;
@@ -16427,6 +19179,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DebugUtilsObjectTagInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsObjectTagInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectTagInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, debugUtilsObjectTagInfoEXT.objectType );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectTagInfoEXT.objectHandle );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectTagInfoEXT.tagName );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, debugUtilsObjectTagInfoEXT.tagSize );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectTagInfoEXT.pTag );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DedicatedAllocationBufferCreateInfoNV
   {
     using NativeType = VkDedicatedAllocationBufferCreateInfoNV;
@@ -16518,6 +19292,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DedicatedAllocationBufferCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const &
+                            dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationBufferCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationBufferCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DedicatedAllocationImageCreateInfoNV
   {
     using NativeType = VkDedicatedAllocationImageCreateInfoNV;
@@ -16609,6 +19402,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DedicatedAllocationImageCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const &
+                            dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationImageCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationImageCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DedicatedAllocationMemoryAllocateInfoNV
   {
     using NativeType = VkDedicatedAllocationMemoryAllocateInfoNV;
@@ -16713,6 +19525,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DedicatedAllocationMemoryAllocateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const &
+                            dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationMemoryAllocateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationMemoryAllocateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, dedicatedAllocationMemoryAllocateInfoNV.image );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, dedicatedAllocationMemoryAllocateInfoNV.buffer );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryBarrier2KHR
   {
     using NativeType = VkMemoryBarrier2KHR;
@@ -16830,6 +19661,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryBarrier2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR const & memoryBarrier2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryBarrier2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryBarrier2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, memoryBarrier2KHR.srcStageMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, memoryBarrier2KHR.srcAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, memoryBarrier2KHR.dstStageMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, memoryBarrier2KHR.dstAccessMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageSubresourceRange
   {
     using NativeType = VkImageSubresourceRange;
@@ -16935,6 +19786,26 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageSubresourceRange>::value,
                             "ImageSubresourceRange is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageSubresourceRange>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresourceRange.aspectMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.baseMipLevel );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.levelCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.baseArrayLayer );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.layerCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageMemoryBarrier2KHR
   {
     using NativeType = VkImageMemoryBarrier2KHR;
@@ -17115,6 +19986,34 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageMemoryBarrier2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR const & imageMemoryBarrier2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryBarrier2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryBarrier2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, imageMemoryBarrier2KHR.srcStageMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, imageMemoryBarrier2KHR.srcAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, imageMemoryBarrier2KHR.dstStageMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, imageMemoryBarrier2KHR.dstAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier2KHR.oldLayout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier2KHR.newLayout );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier2KHR.srcQueueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier2KHR.dstQueueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryBarrier2KHR.image );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageMemoryBarrier2KHR.subresourceRange );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DependencyInfoKHR
   {
     using NativeType = VkDependencyInfoKHR;
@@ -17317,6 +20216,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DependencyInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DependencyInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfoKHR const & dependencyInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dependencyInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, dependencyInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, dependencyInfoKHR.dependencyFlags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.memoryBarrierCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR *, seed, dependencyInfoKHR.pMemoryBarriers );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.bufferMemoryBarrierCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR *, seed, dependencyInfoKHR.pBufferMemoryBarriers );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.imageMemoryBarrierCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR *, seed, dependencyInfoKHR.pImageMemoryBarriers );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorBufferInfo
   {
     using NativeType = VkDescriptorBufferInfo;
@@ -17403,6 +20327,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo>::value,
                             "DescriptorBufferInfo is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, descriptorBufferInfo.buffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, descriptorBufferInfo.offset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, descriptorBufferInfo.range );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorImageInfo
   {
     using NativeType = VkDescriptorImageInfo;
@@ -17491,6 +20433,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorImageInfo>::value,
                             "DescriptorImageInfo is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorImageInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Sampler, seed, descriptorImageInfo.sampler );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, descriptorImageInfo.imageView );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, descriptorImageInfo.imageLayout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorPoolSize
   {
     using NativeType = VkDescriptorPoolSize;
@@ -17568,6 +20528,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorPoolSize>::value,
                             "DescriptorPoolSize is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorPoolSize.type );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolSize.descriptorCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorPoolCreateInfo
   {
     using NativeType = VkDescriptorPoolCreateInfo;
@@ -17706,6 +20683,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DescriptorPoolCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorPoolCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorPoolCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags, seed, descriptorPoolCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolCreateInfo.maxSets );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolCreateInfo.poolSizeCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DescriptorPoolSize *, seed, descriptorPoolCreateInfo.pPoolSizes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorPoolInlineUniformBlockCreateInfoEXT
   {
     using NativeType = VkDescriptorPoolInlineUniformBlockCreateInfoEXT;
@@ -17802,6 +20801,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DescriptorPoolInlineUniformBlockCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfoEXT const &
+                            descriptorPoolInlineUniformBlockCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.maxInlineUniformBlockBindings );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorSetAllocateInfo
   {
     using NativeType = VkDescriptorSetAllocateInfo;
@@ -17932,6 +20951,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DescriptorSetAllocateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetAllocateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetAllocateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorPool, seed, descriptorSetAllocateInfo.descriptorPool );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetAllocateInfo.descriptorSetCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DescriptorSetLayout *, seed, descriptorSetAllocateInfo.pSetLayouts );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorSetLayoutBinding
   {
     using NativeType = VkDescriptorSetLayoutBinding;
@@ -18068,6 +21108,27 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding>::value,
                             "DescriptorSetLayoutBinding is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBinding.binding );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorSetLayoutBinding.descriptorType );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBinding.descriptorCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, descriptorSetLayoutBinding.stageFlags );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::Sampler *, seed, descriptorSetLayoutBinding.pImmutableSamplers );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorSetLayoutBindingFlagsCreateInfo
   {
     using NativeType = VkDescriptorSetLayoutBindingFlagsCreateInfo;
@@ -18194,6 +21255,28 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const &
+                            descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutBindingFlagsCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags *,
+                             seed,
+                             descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorSetLayoutCreateInfo
   {
     using NativeType = VkDescriptorSetLayoutCreateInfo;
@@ -18324,6 +21407,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DescriptorSetLayoutCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetLayoutCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags, seed, descriptorSetLayoutCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutCreateInfo.bindingCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding *, seed, descriptorSetLayoutCreateInfo.pBindings );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorSetLayoutSupport
   {
     using NativeType = VkDescriptorSetLayoutSupport;
@@ -18396,6 +21501,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutSupport.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, descriptorSetLayoutSupport.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, descriptorSetLayoutSupport.supported );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorSetVariableDescriptorCountAllocateInfo
   {
     using NativeType = VkDescriptorSetVariableDescriptorCountAllocateInfo;
@@ -18521,6 +21644,27 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const &
+                            descriptorSetVariableDescriptorCountAllocateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetVariableDescriptorCountAllocateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const uint32_t *, seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorSetVariableDescriptorCountLayoutSupport
   {
     using NativeType = VkDescriptorSetVariableDescriptorCountLayoutSupport;
@@ -18603,6 +21747,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const &
+                            descriptorSetVariableDescriptorCountLayoutSupport ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetVariableDescriptorCountLayoutSupport.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorUpdateTemplateEntry
   {
     using NativeType = VkDescriptorUpdateTemplateEntry;
@@ -18725,6 +21889,27 @@ namespace VULKAN_HPP_NAMESPACE
     "DescriptorUpdateTemplateEntry is not nothrow_move_constructible!" );
   using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.dstBinding );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.dstArrayElement );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.descriptorCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorUpdateTemplateEntry.descriptorType );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, descriptorUpdateTemplateEntry.offset );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, descriptorUpdateTemplateEntry.stride );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DescriptorUpdateTemplateCreateInfo
   {
     using NativeType = VkDescriptorUpdateTemplateCreateInfo;
@@ -18925,6 +22110,38 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const &
+                            descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorUpdateTemplateCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorUpdateTemplateCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags, seed, descriptorUpdateTemplateCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry *,
+                             seed,
+                             descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType, seed, descriptorUpdateTemplateCreateInfo.templateType );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DescriptorSetLayout, seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineLayout, seed, descriptorUpdateTemplateCreateInfo.pipelineLayout );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateCreateInfo.set );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceBufferMemoryRequirementsKHR
   {
     using NativeType = VkDeviceBufferMemoryRequirementsKHR;
@@ -19015,6 +22232,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceBufferMemoryRequirementsKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR const &
+                            deviceBufferMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceBufferMemoryRequirementsKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceBufferMemoryRequirementsKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::BufferCreateInfo *, seed, deviceBufferMemoryRequirementsKHR.pCreateInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceQueueCreateInfo
   {
     using NativeType = VkDeviceQueueCreateInfo;
@@ -19151,6 +22387,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceQueueCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags, seed, deviceQueueCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueCreateInfo.queueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueCreateInfo.queueCount );
+    VULKAN_HPP_HASH_COMBINE( const float *, seed, deviceQueueCreateInfo.pQueuePriorities );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFeatures
   {
     using NativeType = VkPhysicalDeviceFeatures;
@@ -19799,6 +23056,85 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures>::value,
                             "PhysicalDeviceFeatures is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.robustBufferAccess );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fullDrawIndexUint32 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.imageCubeArray );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.independentBlend );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.geometryShader );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.tessellationShader );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sampleRateShading );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.dualSrcBlend );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.logicOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.multiDrawIndirect );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.drawIndirectFirstInstance );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthClamp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthBiasClamp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fillModeNonSolid );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthBounds );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.wideLines );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.largePoints );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.alphaToOne );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.multiViewport );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.samplerAnisotropy );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionETC2 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionASTC_LDR );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionBC );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.occlusionQueryPrecise );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.pipelineStatisticsQuery );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fragmentStoresAndAtomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderImageGatherExtended );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageMultisample );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderClipDistance );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderCullDistance );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderFloat64 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderInt64 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderInt16 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderResourceResidency );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderResourceMinLod );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseBinding );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyBuffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyImage2D );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyImage3D );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency2Samples );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency4Samples );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency8Samples );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency16Samples );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyAliased );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.variableMultisampleRate );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.inheritedQueries );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceCreateInfo
   {
     using NativeType = VkDeviceCreateInfo;
@@ -20008,6 +23344,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceCreateFlags, seed, deviceCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.queueCreateInfoCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo *, seed, deviceCreateInfo.pQueueCreateInfos );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.enabledLayerCount );
+    VULKAN_HPP_HASH_COMBINE( const char * const *, seed, deviceCreateInfo.ppEnabledLayerNames );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.enabledExtensionCount );
+    VULKAN_HPP_HASH_COMBINE( const char * const *, seed, deviceCreateInfo.ppEnabledExtensionNames );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures *, seed, deviceCreateInfo.pEnabledFeatures );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceDeviceMemoryReportCreateInfoEXT
   {
     using NativeType = VkDeviceDeviceMemoryReportCreateInfoEXT;
@@ -20121,6 +23483,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceDeviceMemoryReportCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const &
+                            deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceDeviceMemoryReportCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceDeviceMemoryReportCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT, seed, deviceDeviceMemoryReportCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      PFN_vkDeviceMemoryReportCallbackEXT, seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceDiagnosticsConfigCreateInfoNV
   {
     using NativeType = VkDeviceDiagnosticsConfigCreateInfoNV;
@@ -20211,6 +23595,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceDiagnosticsConfigCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const &
+                            deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceDiagnosticsConfigCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceDiagnosticsConfigCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV, seed, deviceDiagnosticsConfigCreateInfoNV.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceEventInfoEXT
   {
     using NativeType = VkDeviceEventInfoEXT;
@@ -20297,6 +23700,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceEventInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceEventInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceEventInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT, seed, deviceEventInfoEXT.deviceEvent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceGroupBindSparseInfo
   {
     using NativeType = VkDeviceGroupBindSparseInfo;
@@ -20395,6 +23816,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupBindSparseInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupBindSparseInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupBindSparseInfo.resourceDeviceIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupBindSparseInfo.memoryDeviceIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceGroupCommandBufferBeginInfo
   {
     using NativeType = VkDeviceGroupCommandBufferBeginInfo;
@@ -20485,6 +23925,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const &
+                            deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupCommandBufferBeginInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupCommandBufferBeginInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupCommandBufferBeginInfo.deviceMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceGroupDeviceCreateInfo
   {
     using NativeType = VkDeviceGroupDeviceCreateInfo;
@@ -20605,6 +24063,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupDeviceCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupDeviceCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupDeviceCreateInfo.physicalDeviceCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::PhysicalDevice *, seed, deviceGroupDeviceCreateInfo.pPhysicalDevices );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceGroupPresentCapabilitiesKHR
   {
     using NativeType = VkDeviceGroupPresentCapabilitiesKHR;
@@ -20684,6 +24162,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceGroupPresentCapabilitiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const &
+                            deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupPresentCapabilitiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, deviceGroupPresentCapabilitiesKHR.pNext );
+    for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR, seed, deviceGroupPresentCapabilitiesKHR.modes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceGroupPresentInfoKHR
   {
     using NativeType = VkDeviceGroupPresentInfoKHR;
@@ -20814,6 +24315,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceGroupPresentInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupPresentInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupPresentInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupPresentInfoKHR.swapchainCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupPresentInfoKHR.pDeviceMasks );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR, seed, deviceGroupPresentInfoKHR.mode );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceGroupRenderPassBeginInfo
   {
     using NativeType = VkDeviceGroupRenderPassBeginInfo;
@@ -20945,6 +24467,27 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupRenderPassBeginInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupRenderPassBeginInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupRenderPassBeginInfo.deviceMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::Rect2D *, seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceGroupSubmitInfo
   {
     using NativeType = VkDeviceGroupSubmitInfo;
@@ -21133,6 +24676,29 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupSubmitInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupSubmitInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.waitSemaphoreCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.commandBufferCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.signalSemaphoreCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceGroupSwapchainCreateInfoKHR
   {
     using NativeType = VkDeviceGroupSwapchainCreateInfoKHR;
@@ -21222,6 +24788,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceGroupSwapchainCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const &
+                            deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupSwapchainCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupSwapchainCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR, seed, deviceGroupSwapchainCreateInfoKHR.modes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageCreateInfo
   {
     using NativeType = VkImageCreateInfo;
@@ -21468,6 +25053,35 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, imageCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, imageCreateInfo.imageType );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageCreateInfo.format );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCreateInfo.extent );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.mipLevels );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.arrayLayers );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, imageCreateInfo.samples );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, imageCreateInfo.tiling );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageCreateInfo.usage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, imageCreateInfo.sharingMode );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.queueFamilyIndexCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, imageCreateInfo.pQueueFamilyIndices );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageCreateInfo.initialLayout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceImageMemoryRequirementsKHR
   {
     using NativeType = VkDeviceImageMemoryRequirementsKHR;
@@ -21569,6 +25183,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceImageMemoryRequirementsKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR const & deviceImageMemoryRequirementsKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceImageMemoryRequirementsKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceImageMemoryRequirementsKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::ImageCreateInfo *, seed, deviceImageMemoryRequirementsKHR.pCreateInfo );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, deviceImageMemoryRequirementsKHR.planeAspect );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceMemoryOpaqueCaptureAddressInfo
   {
     using NativeType = VkDeviceMemoryOpaqueCaptureAddressInfo;
@@ -21661,6 +25297,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const &
+                            deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryOpaqueCaptureAddressInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceMemoryOpaqueCaptureAddressInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, deviceMemoryOpaqueCaptureAddressInfo.memory );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceMemoryOverallocationCreateInfoAMD
   {
     using NativeType = VkDeviceMemoryOverallocationCreateInfoAMD;
@@ -21758,6 +25412,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceMemoryOverallocationCreateInfoAMD;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const &
+                            deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryOverallocationCreateInfoAMD.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceMemoryOverallocationCreateInfoAMD.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD,
+                             seed,
+                             deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceMemoryReportCallbackDataEXT
   {
     using NativeType = VkDeviceMemoryReportCallbackDataEXT;
@@ -21855,6 +25529,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceMemoryReportCallbackDataEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const &
+                            deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryReportCallbackDataEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, deviceMemoryReportCallbackDataEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT, seed, deviceMemoryReportCallbackDataEXT.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT, seed, deviceMemoryReportCallbackDataEXT.type );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, deviceMemoryReportCallbackDataEXT.memoryObjectId );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, deviceMemoryReportCallbackDataEXT.size );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, deviceMemoryReportCallbackDataEXT.objectType );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, deviceMemoryReportCallbackDataEXT.objectHandle );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceMemoryReportCallbackDataEXT.heapIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DevicePrivateDataCreateInfoEXT
   {
     using NativeType = VkDevicePrivateDataCreateInfoEXT;
@@ -21945,6 +25645,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DevicePrivateDataCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfoEXT const & devicePrivateDataCreateInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, devicePrivateDataCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, devicePrivateDataCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, devicePrivateDataCreateInfoEXT.privateDataSlotRequestCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceQueueGlobalPriorityCreateInfoEXT
   {
     using NativeType = VkDeviceQueueGlobalPriorityCreateInfoEXT;
@@ -22039,6 +25757,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceQueueGlobalPriorityCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT const &
+                            deviceQueueGlobalPriorityCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueGlobalPriorityCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueGlobalPriorityCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT, seed, deviceQueueGlobalPriorityCreateInfoEXT.globalPriority );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DeviceQueueInfo2
   {
     using NativeType = VkDeviceQueueInfo2;
@@ -22142,6 +25879,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceQueueInfo2;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueInfo2.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueInfo2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags, seed, deviceQueueInfo2.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueInfo2.queueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueInfo2.queueIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
   struct DirectFBSurfaceCreateInfoEXT
   {
@@ -22248,6 +26004,28 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = DirectFBSurfaceCreateInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, directFBSurfaceCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, directFBSurfaceCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT, seed, directFBSurfaceCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( IDirectFB *, seed, directFBSurfaceCreateInfoEXT.dfb );
+    VULKAN_HPP_HASH_COMBINE( IDirectFBSurface *, seed, directFBSurfaceCreateInfoEXT.surface );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
 
   struct DispatchIndirectCommand
@@ -22334,6 +26112,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand>::value,
                             "DispatchIndirectCommand is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.x );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.y );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.z );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayEventInfoEXT
   {
     using NativeType = VkDisplayEventInfoEXT;
@@ -22420,6 +26216,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayEventInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayEventInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, displayEventInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT, seed, displayEventInfoEXT.displayEvent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayModeParametersKHR
   {
     using NativeType = VkDisplayModeParametersKHR;
@@ -22497,6 +26311,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR>::value,
                             "DisplayModeParametersKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayModeParametersKHR.visibleRegion );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayModeParametersKHR.refreshRate );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayModeCreateInfoKHR
   {
     using NativeType = VkDisplayModeCreateInfoKHR;
@@ -22594,6 +26425,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayModeCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayModeCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, displayModeCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR, seed, displayModeCreateInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR, seed, displayModeCreateInfoKHR.parameters );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayModePropertiesKHR
   {
     using NativeType = VkDisplayModePropertiesKHR;
@@ -22657,6 +26508,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value,
                             "DisplayModePropertiesKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displayModePropertiesKHR.displayMode );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR, seed, displayModePropertiesKHR.parameters );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayModeProperties2KHR
   {
     using NativeType = VkDisplayModeProperties2KHR;
@@ -22729,6 +26598,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayModeProperties2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayModeProperties2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, displayModeProperties2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, seed, displayModeProperties2KHR.displayModeProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayNativeHdrSurfaceCapabilitiesAMD
   {
     using NativeType = VkDisplayNativeHdrSurfaceCapabilitiesAMD;
@@ -22807,6 +26695,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayNativeHdrSurfaceCapabilitiesAMD;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const &
+                            displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayNativeHdrSurfaceCapabilitiesAMD.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayPlaneCapabilitiesKHR
   {
     using NativeType = VkDisplayPlaneCapabilitiesKHR;
@@ -22897,6 +26804,31 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::value,
     "DisplayPlaneCapabilitiesKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR, seed, displayPlaneCapabilitiesKHR.supportedAlpha );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.minSrcPosition );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.maxSrcPosition );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.minSrcExtent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.maxSrcExtent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.minDstPosition );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.maxDstPosition );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.minDstExtent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.maxDstExtent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayPlaneCapabilities2KHR
   {
     using NativeType = VkDisplayPlaneCapabilities2KHR;
@@ -22970,6 +26902,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayPlaneCapabilities2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneCapabilities2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, displayPlaneCapabilities2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR, seed, displayPlaneCapabilities2KHR.capabilities );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayPlaneInfo2KHR
   {
     using NativeType = VkDisplayPlaneInfo2KHR;
@@ -23064,6 +27015,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayPlaneInfo2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneInfo2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPlaneInfo2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displayPlaneInfo2KHR.mode );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayPlaneInfo2KHR.planeIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayPlanePropertiesKHR
   {
     using NativeType = VkDisplayPlanePropertiesKHR;
@@ -23127,6 +27097,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value,
                             "DisplayPlanePropertiesKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayKHR, seed, displayPlanePropertiesKHR.currentDisplay );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayPlanePropertiesKHR.currentStackIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayPlaneProperties2KHR
   {
     using NativeType = VkDisplayPlaneProperties2KHR;
@@ -23200,6 +27187,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayPlaneProperties2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneProperties2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, displayPlaneProperties2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, seed, displayPlaneProperties2KHR.displayPlaneProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayPowerInfoEXT
   {
     using NativeType = VkDisplayPowerInfoEXT;
@@ -23285,6 +27291,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayPowerInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPowerInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPowerInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT, seed, displayPowerInfoEXT.powerState );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayPresentInfoKHR
   {
     using NativeType = VkDisplayPresentInfoKHR;
@@ -23390,6 +27414,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayPresentInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPresentInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPresentInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, displayPresentInfoKHR.srcRect );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, displayPresentInfoKHR.dstRect );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPresentInfoKHR.persistent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayPropertiesKHR
   {
     using NativeType = VkDisplayPropertiesKHR;
@@ -23470,6 +27514,29 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value,
                             "DisplayPropertiesKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayKHR, seed, displayPropertiesKHR.display );
+    VULKAN_HPP_HASH_COMBINE( const char *, seed, displayPropertiesKHR.displayName );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPropertiesKHR.physicalDimensions );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPropertiesKHR.physicalResolution );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, displayPropertiesKHR.supportedTransforms );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPropertiesKHR.planeReorderPossible );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPropertiesKHR.persistentContent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplayProperties2KHR
   {
     using NativeType = VkDisplayProperties2KHR;
@@ -23540,6 +27607,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplayProperties2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayProperties2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, displayProperties2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, seed, displayProperties2KHR.displayProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DisplaySurfaceCreateInfoKHR
   {
     using NativeType = VkDisplaySurfaceCreateInfoKHR;
@@ -23703,6 +27789,34 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DisplaySurfaceCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displaySurfaceCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, displaySurfaceCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR, seed, displaySurfaceCreateInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displaySurfaceCreateInfoKHR.displayMode );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displaySurfaceCreateInfoKHR.planeIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displaySurfaceCreateInfoKHR.planeStackIndex );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, displaySurfaceCreateInfoKHR.transform );
+    VULKAN_HPP_HASH_COMBINE( float, seed, displaySurfaceCreateInfoKHR.globalAlpha );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR, seed, displaySurfaceCreateInfoKHR.alphaMode );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displaySurfaceCreateInfoKHR.imageExtent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DrawIndexedIndirectCommand
   {
     using NativeType = VkDrawIndexedIndirectCommand;
@@ -23809,6 +27923,26 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand>::value,
                             "DrawIndexedIndirectCommand is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.indexCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.instanceCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.firstIndex );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, drawIndexedIndirectCommand.vertexOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.firstInstance );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DrawIndirectCommand
   {
     using NativeType = VkDrawIndirectCommand;
@@ -23903,6 +28037,25 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrawIndirectCommand>::value,
                             "DrawIndirectCommand is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DrawIndirectCommand>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.vertexCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.instanceCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.firstVertex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.firstInstance );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DrawMeshTasksIndirectCommandNV
   {
     using NativeType = VkDrawMeshTasksIndirectCommandNV;
@@ -23982,6 +28135,23 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV>::value,
     "DrawMeshTasksIndirectCommandNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawMeshTasksIndirectCommandNV.taskCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawMeshTasksIndirectCommandNV.firstTask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DrmFormatModifierProperties2EXT
   {
     using NativeType = VkDrmFormatModifierProperties2EXT;
@@ -24053,6 +28223,27 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT>::value,
     "DrmFormatModifierProperties2EXT is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, drmFormatModifierProperties2EXT.drmFormatModifier );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR,
+                             seed,
+                             drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DrmFormatModifierPropertiesEXT
   {
     using NativeType = VkDrmFormatModifierPropertiesEXT;
@@ -24124,6 +28315,25 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT>::value,
     "DrmFormatModifierPropertiesEXT is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, drmFormatModifierPropertiesEXT.drmFormatModifier );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DrmFormatModifierPropertiesList2EXT
   {
     using NativeType = VkDrmFormatModifierPropertiesList2EXT;
@@ -24214,6 +28424,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DrmFormatModifierPropertiesList2EXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const &
+                            drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, drmFormatModifierPropertiesList2EXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, drmFormatModifierPropertiesList2EXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT *,
+                             seed,
+                             drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct DrmFormatModifierPropertiesListEXT
   {
     using NativeType = VkDrmFormatModifierPropertiesListEXT;
@@ -24304,6 +28535,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DrmFormatModifierPropertiesListEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const &
+                            drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, drmFormatModifierPropertiesListEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, drmFormatModifierPropertiesListEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT *,
+                             seed,
+                             drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct EventCreateInfo
   {
     using NativeType = VkEventCreateInfo;
@@ -24388,6 +28640,23 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = EventCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::EventCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, eventCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, eventCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::EventCreateFlags, seed, eventCreateInfo.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ExportFenceCreateInfo
   {
     using NativeType = VkExportFenceCreateInfo;
@@ -24474,6 +28743,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportFenceCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportFenceCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, exportFenceCreateInfo.handleTypes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ExportFenceWin32HandleInfoKHR
   {
@@ -24581,6 +28869,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ExportFenceWin32HandleInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportFenceWin32HandleInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportFenceWin32HandleInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportFenceWin32HandleInfoKHR.pAttributes );
+    VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportFenceWin32HandleInfoKHR.dwAccess );
+    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportFenceWin32HandleInfoKHR.name );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ExportMemoryAllocateInfo
@@ -24670,6 +28979,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryAllocateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryAllocateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, exportMemoryAllocateInfo.handleTypes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ExportMemoryAllocateInfoNV
   {
     using NativeType = VkExportMemoryAllocateInfoNV;
@@ -24757,6 +29085,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ExportMemoryAllocateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryAllocateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryAllocateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, exportMemoryAllocateInfoNV.handleTypes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ExportMemoryWin32HandleInfoKHR
   {
@@ -24864,6 +29211,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ExportMemoryWin32HandleInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryWin32HandleInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryWin32HandleInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportMemoryWin32HandleInfoKHR.pAttributes );
+    VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportMemoryWin32HandleInfoKHR.dwAccess );
+    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportMemoryWin32HandleInfoKHR.name );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -24964,6 +29332,26 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ExportMemoryWin32HandleInfoNV;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryWin32HandleInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryWin32HandleInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportMemoryWin32HandleInfoNV.pAttributes );
+    VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportMemoryWin32HandleInfoNV.dwAccess );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ExportSemaphoreCreateInfo
@@ -25054,6 +29442,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportSemaphoreCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportSemaphoreCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags, seed, exportSemaphoreCreateInfo.handleTypes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ExportSemaphoreWin32HandleInfoKHR
   {
@@ -25162,6 +29569,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ExportSemaphoreWin32HandleInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const &
+                            exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportSemaphoreWin32HandleInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, exportSemaphoreWin32HandleInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportSemaphoreWin32HandleInfoKHR.pAttributes );
+    VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportSemaphoreWin32HandleInfoKHR.dwAccess );
+    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportSemaphoreWin32HandleInfoKHR.name );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ExtensionProperties
@@ -25226,6 +29654,26 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExtensionProperties>::value,
                             "ExtensionProperties is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExtensionProperties>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, extensionProperties.extensionName[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extensionProperties.specVersion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ExternalMemoryProperties
   {
     using NativeType = VkExternalMemoryProperties;
@@ -25295,6 +29743,28 @@ namespace VULKAN_HPP_NAMESPACE
                             "ExternalMemoryProperties is not nothrow_move_constructible!" );
   using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags, seed, externalMemoryProperties.externalMemoryFeatures );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags,
+                             seed,
+                             externalMemoryProperties.exportFromImportedHandleTypes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryProperties.compatibleHandleTypes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ExternalBufferProperties
   {
     using NativeType = VkExternalBufferProperties;
@@ -25368,6 +29838,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalBufferPropertiesKHR = ExternalBufferProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExternalBufferProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalBufferProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, externalBufferProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryProperties, seed, externalBufferProperties.externalMemoryProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ExternalFenceProperties
   {
     using NativeType = VkExternalFenceProperties;
@@ -25449,6 +29938,29 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalFencePropertiesKHR = ExternalFenceProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalFenceProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, externalFenceProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, externalFenceProperties.exportFromImportedHandleTypes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, externalFenceProperties.compatibleHandleTypes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags, seed, externalFenceProperties.externalFenceFeatures );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
   struct ExternalFormatANDROID
   {
@@ -25532,6 +30044,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ExternalFormatANDROID;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExternalFormatANDROID>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalFormatANDROID.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, externalFormatANDROID.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, externalFormatANDROID.externalFormat );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct ExternalImageFormatProperties
@@ -25610,6 +30141,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalImageFormatProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, externalImageFormatProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryProperties, seed, externalImageFormatProperties.externalMemoryProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageFormatProperties
   {
     using NativeType = VkImageFormatProperties;
@@ -25683,6 +30233,26 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::value,
                             "ImageFormatProperties is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageFormatProperties.maxExtent );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatProperties.maxMipLevels );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatProperties.maxArrayLayers );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, imageFormatProperties.sampleCounts );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, imageFormatProperties.maxResourceSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ExternalImageFormatPropertiesNV
   {
     using NativeType = VkExternalImageFormatPropertiesNV;
@@ -25758,6 +30328,33 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::value,
     "ExternalImageFormatPropertiesNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageFormatProperties, seed, externalImageFormatPropertiesNV.imageFormatProperties );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV,
+                             seed,
+                             externalImageFormatPropertiesNV.externalMemoryFeatures );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV,
+                             seed,
+                             externalImageFormatPropertiesNV.exportFromImportedHandleTypes );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV,
+                             seed,
+                             externalImageFormatPropertiesNV.compatibleHandleTypes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ExternalMemoryBufferCreateInfo
   {
     using NativeType = VkExternalMemoryBufferCreateInfo;
@@ -25848,6 +30445,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryBufferCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryBufferCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryBufferCreateInfo.handleTypes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ExternalMemoryImageCreateInfo
   {
     using NativeType = VkExternalMemoryImageCreateInfo;
@@ -25938,6 +30554,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryImageCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryImageCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryImageCreateInfo.handleTypes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ExternalMemoryImageCreateInfoNV
   {
     using NativeType = VkExternalMemoryImageCreateInfoNV;
@@ -26027,6 +30662,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ExternalMemoryImageCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryImageCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryImageCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, externalMemoryImageCreateInfoNV.handleTypes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ExternalSemaphoreProperties
   {
     using NativeType = VkExternalSemaphoreProperties;
@@ -26110,6 +30765,31 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalSemaphoreProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, externalSemaphoreProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags,
+                             seed,
+                             externalSemaphoreProperties.exportFromImportedHandleTypes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags, seed, externalSemaphoreProperties.compatibleHandleTypes );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags,
+                             seed,
+                             externalSemaphoreProperties.externalSemaphoreFeatures );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct FenceCreateInfo
   {
     using NativeType = VkFenceCreateInfo;
@@ -26194,6 +30874,23 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FenceCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FenceCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceCreateFlags, seed, fenceCreateInfo.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct FenceGetFdInfoKHR
   {
     using NativeType = VkFenceGetFdInfoKHR;
@@ -26291,6 +30988,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FenceGetFdInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceGetFdInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceGetFdInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, fenceGetFdInfoKHR.fence );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, fenceGetFdInfoKHR.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct FenceGetWin32HandleInfoKHR
   {
@@ -26391,6 +31107,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = FenceGetWin32HandleInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceGetWin32HandleInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceGetWin32HandleInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, fenceGetWin32HandleInfoKHR.fence );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, fenceGetWin32HandleInfoKHR.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct FilterCubicImageViewImageFormatPropertiesEXT
@@ -26476,6 +31213,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FilterCubicImageViewImageFormatPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const &
+                            filterCubicImageViewImageFormatPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, filterCubicImageViewImageFormatPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, filterCubicImageViewImageFormatPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct FormatProperties
   {
     using NativeType = VkFormatProperties;
@@ -26542,6 +31301,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::FormatProperties>::value,
                             "FormatProperties is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FormatProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.linearTilingFeatures );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.optimalTilingFeatures );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.bufferFeatures );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct FormatProperties2
   {
     using NativeType = VkFormatProperties2;
@@ -26613,6 +31389,23 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using FormatProperties2KHR = FormatProperties2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FormatProperties2>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, formatProperties2.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, formatProperties2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatProperties, seed, formatProperties2.formatProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct FormatProperties3KHR
   {
     using NativeType = VkFormatProperties3KHR;
@@ -26690,6 +31483,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FormatProperties3KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FormatProperties3KHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::FormatProperties3KHR const & formatProperties3KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, formatProperties3KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, formatProperties3KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.linearTilingFeatures );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.optimalTilingFeatures );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.bufferFeatures );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct FragmentShadingRateAttachmentInfoKHR
   {
     using NativeType = VkFragmentShadingRateAttachmentInfoKHR;
@@ -26793,6 +31608,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FragmentShadingRateAttachmentInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const &
+                            fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fragmentShadingRateAttachmentInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, fragmentShadingRateAttachmentInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentReference2 *,
+                             seed,
+                             fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Extent2D, seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct FramebufferAttachmentImageInfo
   {
     using NativeType = VkFramebufferAttachmentImageInfo;
@@ -26971,6 +31808,30 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferAttachmentImageInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferAttachmentImageInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, framebufferAttachmentImageInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, framebufferAttachmentImageInfo.usage );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.width );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.height );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.layerCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.viewFormatCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Format *, seed, framebufferAttachmentImageInfo.pViewFormats );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct FramebufferAttachmentsCreateInfo
   {
     using NativeType = VkFramebufferAttachmentsCreateInfo;
@@ -27093,6 +31954,28 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferAttachmentsCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferAttachmentsCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo *,
+                             seed,
+                             framebufferAttachmentsCreateInfo.pAttachmentImageInfos );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct FramebufferCreateInfo
   {
     using NativeType = VkFramebufferCreateInfo;
@@ -27265,6 +32148,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FramebufferCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FramebufferCreateFlags, seed, framebufferCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, framebufferCreateInfo.renderPass );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.attachmentCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageView *, seed, framebufferCreateInfo.pAttachments );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.width );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.height );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.layers );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct FramebufferMixedSamplesCombinationNV
   {
     using NativeType = VkFramebufferMixedSamplesCombinationNV;
@@ -27355,6 +32262,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = FramebufferMixedSamplesCombinationNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const &
+                            framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferMixedSamplesCombinationNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, framebufferMixedSamplesCombinationNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::CoverageReductionModeNV, seed, framebufferMixedSamplesCombinationNV.coverageReductionMode );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, framebufferMixedSamplesCombinationNV.rasterizationSamples );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, framebufferMixedSamplesCombinationNV.depthStencilSamples );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, framebufferMixedSamplesCombinationNV.colorSamples );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct IndirectCommandsStreamNV
   {
     using NativeType = VkIndirectCommandsStreamNV;
@@ -27433,6 +32365,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV>::value,
                             "IndirectCommandsStreamNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, indirectCommandsStreamNV.buffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, indirectCommandsStreamNV.offset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct GeneratedCommandsInfoNV
   {
     using NativeType = VkGeneratedCommandsInfoNV;
@@ -27687,6 +32636,38 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GeneratedCommandsInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, generatedCommandsInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, generatedCommandsInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, generatedCommandsInfoNV.pipelineBindPoint );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, generatedCommandsInfoNV.pipeline );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, seed, generatedCommandsInfoNV.indirectCommandsLayout );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsInfoNV.streamCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV *, seed, generatedCommandsInfoNV.pStreams );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsInfoNV.sequencesCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.preprocessBuffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.preprocessOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.preprocessSize );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.sequencesCountBuffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.sequencesCountOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.sequencesIndexBuffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.sequencesIndexOffset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct GeneratedCommandsMemoryRequirementsInfoNV
   {
     using NativeType = VkGeneratedCommandsMemoryRequirementsInfoNV;
@@ -27814,6 +32795,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GeneratedCommandsMemoryRequirementsInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const &
+                            generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, generatedCommandsMemoryRequirementsInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, generatedCommandsMemoryRequirementsInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, generatedCommandsMemoryRequirementsInfoNV.pipeline );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV,
+                             seed,
+                             generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct VertexInputBindingDescription
   {
     using NativeType = VkVertexInputBindingDescription;
@@ -27905,6 +32911,24 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>::value,
     "VertexInputBindingDescription is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription.binding );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription.stride );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VertexInputRate, seed, vertexInputBindingDescription.inputRate );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct VertexInputAttributeDescription
   {
     using NativeType = VkVertexInputAttributeDescription;
@@ -28005,6 +33029,26 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription>::value,
     "VertexInputAttributeDescription is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.location );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.binding );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, vertexInputAttributeDescription.format );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.offset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineVertexInputStateCreateInfo
   {
     using NativeType = VkPipelineVertexInputStateCreateInfo;
@@ -28178,6 +33222,33 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineVertexInputStateCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const &
+                            pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineVertexInputStateCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineVertexInputStateCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags, seed, pipelineVertexInputStateCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription *,
+                             seed,
+                             pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription *,
+                             seed,
+                             pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineInputAssemblyStateCreateInfo
   {
     using NativeType = VkPipelineInputAssemblyStateCreateInfo;
@@ -28290,6 +33361,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineInputAssemblyStateCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const &
+                            pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineInputAssemblyStateCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineInputAssemblyStateCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags, seed, pipelineInputAssemblyStateCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PrimitiveTopology, seed, pipelineInputAssemblyStateCreateInfo.topology );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineTessellationStateCreateInfo
   {
     using NativeType = VkPipelineTessellationStateCreateInfo;
@@ -28392,6 +33486,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineTessellationStateCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const &
+                            pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineTessellationStateCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineTessellationStateCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags, seed, pipelineTessellationStateCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineTessellationStateCreateInfo.patchControlPoints );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineViewportStateCreateInfo
   {
     using NativeType = VkPipelineViewportStateCreateInfo;
@@ -28558,6 +33672,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportStateCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportStateCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportStateCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags, seed, pipelineViewportStateCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportStateCreateInfo.viewportCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Viewport *, seed, pipelineViewportStateCreateInfo.pViewports );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportStateCreateInfo.scissorCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Rect2D *, seed, pipelineViewportStateCreateInfo.pScissors );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineRasterizationStateCreateInfo
   {
     using NativeType = VkPipelineRasterizationStateCreateInfo;
@@ -28754,6 +33892,38 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationStateCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const &
+                            pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags, seed, pipelineRasterizationStateCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.depthClampEnable );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PolygonMode, seed, pipelineRasterizationStateCreateInfo.polygonMode );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CullModeFlags, seed, pipelineRasterizationStateCreateInfo.cullMode );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FrontFace, seed, pipelineRasterizationStateCreateInfo.frontFace );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.depthBiasEnable );
+    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor );
+    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasClamp );
+    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor );
+    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.lineWidth );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineMultisampleStateCreateInfo
   {
     using NativeType = VkPipelineMultisampleStateCreateInfo;
@@ -28909,6 +34079,35 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineMultisampleStateCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const &
+                            pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineMultisampleStateCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineMultisampleStateCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags, seed, pipelineMultisampleStateCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, pipelineMultisampleStateCreateInfo.rasterizationSamples );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable );
+    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineMultisampleStateCreateInfo.minSampleShading );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SampleMask *, seed, pipelineMultisampleStateCreateInfo.pSampleMask );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct StencilOpState
   {
     using NativeType = VkStencilOpState;
@@ -29034,6 +34233,27 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::StencilOpState>::value,
                             "StencilOpState is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::StencilOpState>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.failOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.passOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.depthFailOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CompareOp, seed, stencilOpState.compareOp );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.compareMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.writeMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.reference );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineDepthStencilStateCreateInfo
   {
     using NativeType = VkPipelineDepthStencilStateCreateInfo;
@@ -29219,6 +34439,37 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineDepthStencilStateCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const &
+                            pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDepthStencilStateCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDepthStencilStateCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags, seed, pipelineDepthStencilStateCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthTestEnable );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::CompareOp, seed, pipelineDepthStencilStateCreateInfo.depthCompareOp );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOpState, seed, pipelineDepthStencilStateCreateInfo.front );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOpState, seed, pipelineDepthStencilStateCreateInfo.back );
+    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineDepthStencilStateCreateInfo.minDepthBounds );
+    VULKAN_HPP_HASH_COMBINE( float, seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineColorBlendAttachmentState
   {
     using NativeType = VkPipelineColorBlendAttachmentState;
@@ -29364,6 +34615,34 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState>::value,
     "PipelineColorBlendAttachmentState is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const &
+                            pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAttachmentState.blendEnable );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.srcColorBlendFactor );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.dstColorBlendFactor );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BlendOp, seed, pipelineColorBlendAttachmentState.colorBlendOp );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BlendOp, seed, pipelineColorBlendAttachmentState.alphaBlendOp );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ColorComponentFlags, seed, pipelineColorBlendAttachmentState.colorWriteMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineColorBlendStateCreateInfo
   {
     using NativeType = VkPipelineColorBlendStateCreateInfo;
@@ -29535,6 +34814,35 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineColorBlendStateCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const &
+                            pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorBlendStateCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorBlendStateCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags, seed, pipelineColorBlendStateCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendStateCreateInfo.logicOpEnable );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::LogicOp, seed, pipelineColorBlendStateCreateInfo.logicOp );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineColorBlendStateCreateInfo.attachmentCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState *,
+                             seed,
+                             pipelineColorBlendStateCreateInfo.pAttachments );
+    for ( size_t i = 0; i < 4; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( float, seed, pipelineColorBlendStateCreateInfo.blendConstants[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineDynamicStateCreateInfo
   {
     using NativeType = VkPipelineDynamicStateCreateInfo;
@@ -29666,6 +34974,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineDynamicStateCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDynamicStateCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDynamicStateCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags, seed, pipelineDynamicStateCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineDynamicStateCreateInfo.dynamicStateCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DynamicState *, seed, pipelineDynamicStateCreateInfo.pDynamicStates );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct GraphicsPipelineCreateInfo
   {
     using NativeType = VkGraphicsPipelineCreateInfo;
@@ -29969,6 +35299,57 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GraphicsPipelineCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsPipelineCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsPipelineCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, graphicsPipelineCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineCreateInfo.stageCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, graphicsPipelineCreateInfo.pStages );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo *,
+                             seed,
+                             graphicsPipelineCreateInfo.pVertexInputState );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo *,
+                             seed,
+                             graphicsPipelineCreateInfo.pInputAssemblyState );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo *,
+                             seed,
+                             graphicsPipelineCreateInfo.pTessellationState );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo *, seed, graphicsPipelineCreateInfo.pViewportState );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo *,
+                             seed,
+                             graphicsPipelineCreateInfo.pRasterizationState );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo *,
+                             seed,
+                             graphicsPipelineCreateInfo.pMultisampleState );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo *,
+                             seed,
+                             graphicsPipelineCreateInfo.pDepthStencilState );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo *,
+                             seed,
+                             graphicsPipelineCreateInfo.pColorBlendState );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo *, seed, graphicsPipelineCreateInfo.pDynamicState );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, graphicsPipelineCreateInfo.layout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, graphicsPipelineCreateInfo.renderPass );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineCreateInfo.subpass );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, graphicsPipelineCreateInfo.basePipelineHandle );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, graphicsPipelineCreateInfo.basePipelineIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct GraphicsShaderGroupCreateInfoNV
   {
     using NativeType = VkGraphicsShaderGroupCreateInfoNV;
@@ -30113,6 +35494,33 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GraphicsShaderGroupCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsShaderGroupCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsShaderGroupCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsShaderGroupCreateInfoNV.stageCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, graphicsShaderGroupCreateInfoNV.pStages );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo *,
+                             seed,
+                             graphicsShaderGroupCreateInfoNV.pVertexInputState );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo *,
+                             seed,
+                             graphicsShaderGroupCreateInfoNV.pTessellationState );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct GraphicsPipelineShaderGroupsCreateInfoNV
   {
     using NativeType = VkGraphicsPipelineShaderGroupsCreateInfoNV;
@@ -30273,6 +35681,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = GraphicsPipelineShaderGroupsCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const &
+                            graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsPipelineShaderGroupsCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV *,
+                             seed,
+                             graphicsPipelineShaderGroupsCreateInfoNV.pGroups );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::Pipeline *, seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct XYColorEXT
   {
     using NativeType = VkXYColorEXT;
@@ -30347,6 +35780,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::XYColorEXT>::value,
                             "XYColorEXT is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::XYColorEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( float, seed, xYColorEXT.x );
+    VULKAN_HPP_HASH_COMBINE( float, seed, xYColorEXT.y );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct HdrMetadataEXT
   {
     using NativeType = VkHdrMetadataEXT;
@@ -30502,6 +35951,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = HdrMetadataEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::HdrMetadataEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, hdrMetadataEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, hdrMetadataEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryRed );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryGreen );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryBlue );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.whitePoint );
+    VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxLuminance );
+    VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.minLuminance );
+    VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxContentLightLevel );
+    VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxFrameAverageLightLevel );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct HeadlessSurfaceCreateInfoEXT
   {
     using NativeType = VkHeadlessSurfaceCreateInfoEXT;
@@ -30589,6 +36062,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = HeadlessSurfaceCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, headlessSurfaceCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, headlessSurfaceCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT, seed, headlessSurfaceCreateInfoEXT.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_IOS_MVK )
   struct IOSSurfaceCreateInfoMVK
   {
@@ -30683,6 +36175,26 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = IOSSurfaceCreateInfoMVK;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, iOSSurfaceCreateInfoMVK.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, iOSSurfaceCreateInfoMVK.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK, seed, iOSSurfaceCreateInfoMVK.flags );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, iOSSurfaceCreateInfoMVK.pView );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_IOS_MVK*/
 
   struct ImageBlit
@@ -30783,6 +36295,30 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageBlit>::value,
                             "ImageBlit is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageBlit>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit.srcSubresource );
+    for ( size_t i = 0; i < 2; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit.srcOffsets[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit.dstSubresource );
+    for ( size_t i = 0; i < 2; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit.dstOffsets[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_FUCHSIA )
   struct ImageFormatConstraintsInfoFUCHSIA
   {
@@ -30926,6 +36462,34 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImageFormatConstraintsInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const &
+                            imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatConstraintsInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageFormatConstraintsInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageCreateInfo, seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA, seed, imageFormatConstraintsInfoFUCHSIA.flags );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA *, seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -31074,6 +36638,33 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImageConstraintsInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageConstraintsInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageConstraintsInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA *,
+                             seed,
+                             imageConstraintsInfoFUCHSIA.pFormatConstraints );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA,
+                             seed,
+                             imageConstraintsInfoFUCHSIA.bufferCollectionConstraints );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIA, seed, imageConstraintsInfoFUCHSIA.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct ImageCopy
@@ -31182,6 +36773,25 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageCopy>::value,
                             "ImageCopy is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageCopy>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy.srcSubresource );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy.srcOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy.dstSubresource );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy.dstOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCopy.extent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubresourceLayout
   {
     using NativeType = VkSubresourceLayout;
@@ -31253,6 +36863,25 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubresourceLayout>::value,
                             "SubresourceLayout is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubresourceLayout>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.offset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.size );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.rowPitch );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.arrayPitch );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.depthPitch );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageDrmFormatModifierExplicitCreateInfoEXT
   {
     using NativeType = VkImageDrmFormatModifierExplicitCreateInfoEXT;
@@ -31392,6 +37021,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageDrmFormatModifierExplicitCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const &
+                            imageDrmFormatModifierExplicitCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubresourceLayout *,
+                             seed,
+                             imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageDrmFormatModifierListCreateInfoEXT
   {
     using NativeType = VkImageDrmFormatModifierListCreateInfoEXT;
@@ -31516,6 +37168,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageDrmFormatModifierListCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const &
+                            imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierListCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageDrmFormatModifierListCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount );
+    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageDrmFormatModifierPropertiesEXT
   {
     using NativeType = VkImageDrmFormatModifierPropertiesEXT;
@@ -31591,6 +37262,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageDrmFormatModifierPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const &
+                            imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, imageDrmFormatModifierPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageFormatListCreateInfo
   {
     using NativeType = VkImageFormatListCreateInfo;
@@ -31708,6 +37397,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatListCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageFormatListCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatListCreateInfo.viewFormatCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Format *, seed, imageFormatListCreateInfo.pViewFormats );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageFormatProperties2
   {
     using NativeType = VkImageFormatProperties2;
@@ -31780,6 +37488,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageFormatProperties2KHR = ImageFormatProperties2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatProperties2.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, imageFormatProperties2.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageFormatProperties, seed, imageFormatProperties2.imageFormatProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageMemoryBarrier
   {
     using NativeType = VkImageMemoryBarrier;
@@ -31938,6 +37665,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageMemoryBarrier;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryBarrier.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryBarrier.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, imageMemoryBarrier.srcAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, imageMemoryBarrier.dstAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier.oldLayout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier.newLayout );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier.srcQueueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier.dstQueueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryBarrier.image );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageMemoryBarrier.subresourceRange );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageMemoryRequirementsInfo2
   {
     using NativeType = VkImageMemoryRequirementsInfo2;
@@ -32026,6 +37778,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryRequirementsInfo2.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryRequirementsInfo2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryRequirementsInfo2.image );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_FUCHSIA )
   struct ImagePipeSurfaceCreateInfoFUCHSIA
   {
@@ -32127,6 +37897,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImagePipeSurfaceCreateInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const &
+                            imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imagePipeSurfaceCreateInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA, seed, imagePipeSurfaceCreateInfoFUCHSIA.flags );
+    VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct ImagePlaneMemoryRequirementsInfo
@@ -32220,6 +38011,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imagePlaneMemoryRequirementsInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imagePlaneMemoryRequirementsInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, imagePlaneMemoryRequirementsInfo.planeAspect );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageResolve
   {
     using NativeType = VkImageResolve;
@@ -32328,6 +38139,25 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageResolve>::value,
                             "ImageResolve is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageResolve>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve.srcSubresource );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve.srcOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve.dstSubresource );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve.dstOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageResolve.extent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageResolve2KHR
   {
     using NativeType = VkImageResolve2KHR;
@@ -32454,6 +38284,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageResolve2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageResolve2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2KHR const & imageResolve2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageResolve2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageResolve2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve2KHR.srcSubresource );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve2KHR.srcOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve2KHR.dstSubresource );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve2KHR.dstOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageResolve2KHR.extent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageSparseMemoryRequirementsInfo2
   {
     using NativeType = VkImageSparseMemoryRequirementsInfo2;
@@ -32546,6 +38397,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const &
+                            imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageSparseMemoryRequirementsInfo2.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageSparseMemoryRequirementsInfo2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageSparseMemoryRequirementsInfo2.image );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageStencilUsageCreateInfo
   {
     using NativeType = VkImageStencilUsageCreateInfo;
@@ -32635,6 +38504,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageStencilUsageCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageStencilUsageCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageStencilUsageCreateInfo.stencilUsage );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageSwapchainCreateInfoKHR
   {
     using NativeType = VkImageSwapchainCreateInfoKHR;
@@ -32723,6 +38610,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageSwapchainCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageSwapchainCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageSwapchainCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, imageSwapchainCreateInfoKHR.swapchain );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageViewASTCDecodeModeEXT
   {
     using NativeType = VkImageViewASTCDecodeModeEXT;
@@ -32810,6 +38715,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageViewASTCDecodeModeEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewASTCDecodeModeEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewASTCDecodeModeEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageViewASTCDecodeModeEXT.decodeMode );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageViewAddressPropertiesNVX
   {
     using NativeType = VkImageViewAddressPropertiesNVX;
@@ -32888,6 +38811,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageViewAddressPropertiesNVX;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewAddressPropertiesNVX.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, imageViewAddressPropertiesNVX.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceAddress, seed, imageViewAddressPropertiesNVX.deviceAddress );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, imageViewAddressPropertiesNVX.size );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageViewCreateInfo
   {
     using NativeType = VkImageViewCreateInfo;
@@ -33023,6 +38965,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageViewCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageViewCreateFlags, seed, imageViewCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageViewCreateInfo.image );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageViewType, seed, imageViewCreateInfo.viewType );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageViewCreateInfo.format );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping, seed, imageViewCreateInfo.components );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageViewCreateInfo.subresourceRange );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageViewHandleInfoNVX
   {
     using NativeType = VkImageViewHandleInfoNVX;
@@ -33130,6 +39095,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageViewHandleInfoNVX;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewHandleInfoNVX.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewHandleInfoNVX.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, imageViewHandleInfoNVX.imageView );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, imageViewHandleInfoNVX.descriptorType );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Sampler, seed, imageViewHandleInfoNVX.sampler );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageViewMinLodCreateInfoEXT
   {
     using NativeType = VkImageViewMinLodCreateInfoEXT;
@@ -33214,6 +39199,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImageViewMinLodCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewMinLodCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewMinLodCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( float, seed, imageViewMinLodCreateInfoEXT.minLod );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImageViewUsageCreateInfo
   {
     using NativeType = VkImageViewUsageCreateInfo;
@@ -33301,6 +39304,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewUsageCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewUsageCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageViewUsageCreateInfo.usage );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
   struct ImportAndroidHardwareBufferInfoANDROID
   {
@@ -33394,6 +39415,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportAndroidHardwareBufferInfoANDROID;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const &
+                            importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importAndroidHardwareBufferInfoANDROID.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importAndroidHardwareBufferInfoANDROID.pNext );
+    VULKAN_HPP_HASH_COMBINE( struct AHardwareBuffer *, seed, importAndroidHardwareBufferInfoANDROID.buffer );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct ImportFenceFdInfoKHR
@@ -33511,6 +39551,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImportFenceFdInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importFenceFdInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importFenceFdInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, importFenceFdInfoKHR.fence );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceImportFlags, seed, importFenceFdInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, importFenceFdInfoKHR.handleType );
+    VULKAN_HPP_HASH_COMBINE( int, seed, importFenceFdInfoKHR.fd );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ImportFenceWin32HandleInfoKHR
   {
@@ -33641,6 +39703,30 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportFenceWin32HandleInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importFenceWin32HandleInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importFenceWin32HandleInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, importFenceWin32HandleInfoKHR.fence );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceImportFlags, seed, importFenceWin32HandleInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, importFenceWin32HandleInfoKHR.handleType );
+    VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importFenceWin32HandleInfoKHR.handle );
+    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importFenceWin32HandleInfoKHR.name );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -33744,6 +39830,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportMemoryBufferCollectionFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const &
+                            importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryBufferCollectionFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryBufferCollectionFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, importMemoryBufferCollectionFUCHSIA.collection );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, importMemoryBufferCollectionFUCHSIA.index );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct ImportMemoryFdInfoKHR
@@ -33841,6 +39948,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImportMemoryFdInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryFdInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryFdInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryFdInfoKHR.handleType );
+    VULKAN_HPP_HASH_COMBINE( int, seed, importMemoryFdInfoKHR.fd );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ImportMemoryHostPointerInfoEXT
   {
     using NativeType = VkImportMemoryHostPointerInfoEXT;
@@ -33942,6 +40069,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImportMemoryHostPointerInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryHostPointerInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryHostPointerInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryHostPointerInfoEXT.handleType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, importMemoryHostPointerInfoEXT.pHostPointer );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ImportMemoryWin32HandleInfoKHR
   {
@@ -34052,6 +40199,28 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportMemoryWin32HandleInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryWin32HandleInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryWin32HandleInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryWin32HandleInfoKHR.handleType );
+    VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importMemoryWin32HandleInfoKHR.handle );
+    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importMemoryWin32HandleInfoKHR.name );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -34153,6 +40322,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportMemoryWin32HandleInfoNV;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryWin32HandleInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryWin32HandleInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, importMemoryWin32HandleInfoNV.handleType );
+    VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importMemoryWin32HandleInfoNV.handle );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -34258,6 +40448,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportMemoryZirconHandleInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const &
+                            importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryZirconHandleInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryZirconHandleInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryZirconHandleInfoFUCHSIA.handleType );
+    VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, importMemoryZirconHandleInfoFUCHSIA.handle );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct ImportSemaphoreFdInfoKHR
@@ -34378,6 +40589,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ImportSemaphoreFdInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreFdInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreFdInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreFdInfoKHR.semaphore );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreFdInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, importSemaphoreFdInfoKHR.handleType );
+    VULKAN_HPP_HASH_COMBINE( int, seed, importSemaphoreFdInfoKHR.fd );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct ImportSemaphoreWin32HandleInfoKHR
   {
@@ -34510,6 +40743,31 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportSemaphoreWin32HandleInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const &
+                            importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreWin32HandleInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreWin32HandleInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreWin32HandleInfoKHR.semaphore );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreWin32HandleInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, importSemaphoreWin32HandleInfoKHR.handleType );
+    VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importSemaphoreWin32HandleInfoKHR.handle );
+    VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importSemaphoreWin32HandleInfoKHR.name );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -34639,6 +40897,31 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ImportSemaphoreZirconHandleInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const &
+                            importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreZirconHandleInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreZirconHandleInfoFUCHSIA.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits,
+                             seed,
+                             importSemaphoreZirconHandleInfoFUCHSIA.handleType );
+    VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct IndirectCommandsLayoutTokenNV
@@ -34919,6 +41202,40 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = IndirectCommandsLayoutTokenNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, indirectCommandsLayoutTokenNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, indirectCommandsLayoutTokenNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV, seed, indirectCommandsLayoutTokenNV.tokenType );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.stream );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.offset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.vertexBindingUnit );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, indirectCommandsLayoutTokenNV.vertexDynamicStride );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineLayout, seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.pushconstantOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.pushconstantSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::IndirectStateFlagsNV, seed, indirectCommandsLayoutTokenNV.indirectStateFlags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.indexTypeCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::IndexType *, seed, indirectCommandsLayoutTokenNV.pIndexTypes );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, indirectCommandsLayoutTokenNV.pIndexTypeValues );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct IndirectCommandsLayoutCreateInfoNV
   {
     using NativeType = VkIndirectCommandsLayoutCreateInfoNV;
@@ -35100,6 +41417,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = IndirectCommandsLayoutCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const &
+                            indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, indirectCommandsLayoutCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, indirectCommandsLayoutCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV, seed, indirectCommandsLayoutCreateInfoNV.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutCreateInfoNV.tokenCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV *, seed, indirectCommandsLayoutCreateInfoNV.pTokens );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutCreateInfoNV.streamCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct InitializePerformanceApiInfoINTEL
   {
     using NativeType = VkInitializePerformanceApiInfoINTEL;
@@ -35188,6 +41531,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = InitializePerformanceApiInfoINTEL;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const &
+                            initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, initializePerformanceApiInfoINTEL.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, initializePerformanceApiInfoINTEL.pNext );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, initializePerformanceApiInfoINTEL.pUserData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct InputAttachmentAspectReference
   {
     using NativeType = VkInputAttachmentAspectReference;
@@ -35281,6 +41642,24 @@ namespace VULKAN_HPP_NAMESPACE
     "InputAttachmentAspectReference is not nothrow_move_constructible!" );
   using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, inputAttachmentAspectReference.subpass );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, inputAttachmentAspectReference.inputAttachmentIndex );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, inputAttachmentAspectReference.aspectMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct InstanceCreateInfo
   {
     using NativeType = VkInstanceCreateInfo;
@@ -35455,6 +41834,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = InstanceCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::InstanceCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, instanceCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, instanceCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::InstanceCreateFlags, seed, instanceCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ApplicationInfo *, seed, instanceCreateInfo.pApplicationInfo );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, instanceCreateInfo.enabledLayerCount );
+    VULKAN_HPP_HASH_COMBINE( const char * const *, seed, instanceCreateInfo.ppEnabledLayerNames );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, instanceCreateInfo.enabledExtensionCount );
+    VULKAN_HPP_HASH_COMBINE( const char * const *, seed, instanceCreateInfo.ppEnabledExtensionNames );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct LayerProperties
   {
     using NativeType = VkLayerProperties;
@@ -35524,6 +41926,30 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LayerProperties>::value,
                             "LayerProperties is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::LayerProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, layerProperties.layerName[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, layerProperties.specVersion );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, layerProperties.implementationVersion );
+    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, layerProperties.description[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_MACOS_MVK )
   struct MacOSSurfaceCreateInfoMVK
   {
@@ -35619,6 +42045,26 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MacOSSurfaceCreateInfoMVK;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, macOSSurfaceCreateInfoMVK.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, macOSSurfaceCreateInfoMVK.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK, seed, macOSSurfaceCreateInfoMVK.flags );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, macOSSurfaceCreateInfoMVK.pView );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
 
   struct MappedMemoryRange
@@ -35725,6 +42171,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MappedMemoryRange;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MappedMemoryRange>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, mappedMemoryRange.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, mappedMemoryRange.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, mappedMemoryRange.memory );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, mappedMemoryRange.offset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, mappedMemoryRange.size );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryAllocateFlagsInfo
   {
     using NativeType = VkMemoryAllocateFlagsInfo;
@@ -35821,6 +42286,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryAllocateFlagsInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryAllocateFlagsInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryAllocateFlags, seed, memoryAllocateFlagsInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryAllocateFlagsInfo.deviceMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryAllocateInfo
   {
     using NativeType = VkMemoryAllocateInfo;
@@ -35915,6 +42399,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryAllocateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryAllocateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryAllocateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryAllocateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryAllocateInfo.allocationSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryAllocateInfo.memoryTypeIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryBarrier
   {
     using NativeType = VkMemoryBarrier;
@@ -36010,6 +42513,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryBarrier;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryBarrier>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryBarrier.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryBarrier.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, memoryBarrier.srcAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, memoryBarrier.dstAccessMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryDedicatedAllocateInfo
   {
     using NativeType = VkMemoryDedicatedAllocateInfo;
@@ -36108,6 +42629,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryDedicatedAllocateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryDedicatedAllocateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, memoryDedicatedAllocateInfo.image );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, memoryDedicatedAllocateInfo.buffer );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryDedicatedRequirements
   {
     using NativeType = VkMemoryDedicatedRequirements;
@@ -36187,6 +42727,27 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryDedicatedRequirements.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryDedicatedRequirements.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, memoryDedicatedRequirements.prefersDedicatedAllocation );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, memoryDedicatedRequirements.requiresDedicatedAllocation );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryFdPropertiesKHR
   {
     using NativeType = VkMemoryFdPropertiesKHR;
@@ -36256,6 +42817,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryFdPropertiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryFdPropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryFdPropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryFdPropertiesKHR.memoryTypeBits );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
   struct MemoryGetAndroidHardwareBufferInfoANDROID
   {
@@ -36351,6 +42930,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MemoryGetAndroidHardwareBufferInfoANDROID;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const &
+                            memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetAndroidHardwareBufferInfoANDROID.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetAndroidHardwareBufferInfoANDROID.memory );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct MemoryGetFdInfoKHR
@@ -36451,6 +43051,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryGetFdInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetFdInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetFdInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetFdInfoKHR.memory );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetFdInfoKHR.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryGetRemoteAddressInfoNV
   {
     using NativeType = VkMemoryGetRemoteAddressInfoNV;
@@ -36552,6 +43172,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryGetRemoteAddressInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetRemoteAddressInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetRemoteAddressInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetRemoteAddressInfoNV.memory );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetRemoteAddressInfoNV.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct MemoryGetWin32HandleInfoKHR
   {
@@ -36653,6 +43293,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MemoryGetWin32HandleInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetWin32HandleInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetWin32HandleInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetWin32HandleInfoKHR.memory );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetWin32HandleInfoKHR.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -36757,6 +43418,28 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MemoryGetZirconHandleInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetZirconHandleInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetZirconHandleInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetZirconHandleInfoFUCHSIA.memory );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetZirconHandleInfoFUCHSIA.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct MemoryHeap
@@ -36820,6 +43503,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryHeap>::value,
                             "MemoryHeap is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryHeap>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryHeap.size );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryHeapFlags, seed, memoryHeap.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryHostPointerPropertiesEXT
   {
     using NativeType = VkMemoryHostPointerPropertiesEXT;
@@ -36893,6 +43592,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryHostPointerPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryHostPointerPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryHostPointerPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryHostPointerPropertiesEXT.memoryTypeBits );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryOpaqueCaptureAddressAllocateInfo
   {
     using NativeType = VkMemoryOpaqueCaptureAddressAllocateInfo;
@@ -36987,6 +43704,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const &
+                            memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryOpaqueCaptureAddressAllocateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryOpaqueCaptureAddressAllocateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryPriorityAllocateInfoEXT
   {
     using NativeType = VkMemoryPriorityAllocateInfoEXT;
@@ -37074,6 +43809,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MemoryPriorityAllocateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryPriorityAllocateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryPriorityAllocateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( float, seed, memoryPriorityAllocateInfoEXT.priority );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryRequirements
   {
     using NativeType = VkMemoryRequirements;
@@ -37138,6 +43891,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryRequirements>::value,
                             "MemoryRequirements is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryRequirements>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryRequirements.size );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryRequirements.alignment );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryRequirements.memoryTypeBits );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryRequirements2
   {
     using NativeType = VkMemoryRequirements2;
@@ -37209,6 +43980,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using MemoryRequirements2KHR = MemoryRequirements2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryRequirements2>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryRequirements2.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryRequirements2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryRequirements, seed, memoryRequirements2.memoryRequirements );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MemoryType
   {
     using NativeType = VkMemoryType;
@@ -37270,6 +44059,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryType>::value,
                             "MemoryType is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryType>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryPropertyFlags, seed, memoryType.propertyFlags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryType.heapIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct MemoryWin32HandlePropertiesKHR
   {
@@ -37343,6 +44148,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MemoryWin32HandlePropertiesKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryWin32HandlePropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryWin32HandlePropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryWin32HandlePropertiesKHR.memoryTypeBits );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -37420,6 +44244,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MemoryZirconHandlePropertiesFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const &
+                            memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryZirconHandlePropertiesFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, memoryZirconHandlePropertiesFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_METAL_EXT )
@@ -37517,6 +44360,26 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = MetalSurfaceCreateInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, metalSurfaceCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, metalSurfaceCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT, seed, metalSurfaceCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( const CAMetalLayer *, seed, metalSurfaceCreateInfoEXT.pLayer );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
 
   struct MultiDrawIndexedInfoEXT
@@ -37605,6 +44468,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT>::value,
                             "MultiDrawIndexedInfoEXT is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawIndexedInfoEXT.firstIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawIndexedInfoEXT.indexCount );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, multiDrawIndexedInfoEXT.vertexOffset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MultiDrawInfoEXT
   {
     using NativeType = VkMultiDrawInfoEXT;
@@ -37679,6 +44560,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT>::value,
                             "MultiDrawInfoEXT is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawInfoEXT.firstVertex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawInfoEXT.vertexCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MultisamplePropertiesEXT
   {
     using NativeType = VkMultisamplePropertiesEXT;
@@ -37751,6 +44648,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MultisamplePropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, multisamplePropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, multisamplePropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, multisamplePropertiesEXT.maxSampleLocationGridSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MultiviewPerViewAttributesInfoNVX
   {
     using NativeType = VkMultiviewPerViewAttributesInfoNVX;
@@ -37852,6 +44767,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MultiviewPerViewAttributesInfoNVX;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const &
+                            multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, multiviewPerViewAttributesInfoNVX.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, multiviewPerViewAttributesInfoNVX.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, multiviewPerViewAttributesInfoNVX.perViewAttributes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MutableDescriptorTypeListVALVE
   {
     using NativeType = VkMutableDescriptorTypeListVALVE;
@@ -37954,6 +44889,24 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE>::value,
     "MutableDescriptorTypeListVALVE is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE const & mutableDescriptorTypeListVALVE )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, mutableDescriptorTypeListVALVE.descriptorTypeCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DescriptorType *, seed, mutableDescriptorTypeListVALVE.pDescriptorTypes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct MutableDescriptorTypeCreateInfoVALVE
   {
     using NativeType = VkMutableDescriptorTypeCreateInfoVALVE;
@@ -38078,6 +45031,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = MutableDescriptorTypeCreateInfoVALVE;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE const &
+                            mutableDescriptorTypeCreateInfoVALVE ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, mutableDescriptorTypeCreateInfoVALVE.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, mutableDescriptorTypeCreateInfoVALVE.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, mutableDescriptorTypeCreateInfoVALVE.mutableDescriptorTypeListCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE *,
+                             seed,
+                             mutableDescriptorTypeCreateInfoVALVE.pMutableDescriptorTypeLists );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PastPresentationTimingGOOGLE
   {
     using NativeType = VkPastPresentationTimingGOOGLE;
@@ -38153,6 +45127,26 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value,
     "PastPresentationTimingGOOGLE is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pastPresentationTimingGOOGLE.presentID );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.desiredPresentTime );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.actualPresentTime );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.earliestPresentTime );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.presentMargin );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PerformanceConfigurationAcquireInfoINTEL
   {
     using NativeType = VkPerformanceConfigurationAcquireInfoINTEL;
@@ -38250,6 +45244,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceConfigurationAcquireInfoINTEL;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const &
+                            performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, performanceConfigurationAcquireInfoINTEL.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceConfigurationAcquireInfoINTEL.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL, seed, performanceConfigurationAcquireInfoINTEL.type );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PerformanceCounterDescriptionKHR
   {
     using NativeType = VkPerformanceCounterDescriptionKHR;
@@ -38334,6 +45348,38 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceCounterDescriptionKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceCounterDescriptionKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, performanceCounterDescriptionKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR, seed, performanceCounterDescriptionKHR.flags );
+    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.name[i] );
+    }
+    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.category[i] );
+    }
+    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.description[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PerformanceCounterKHR
   {
     using NativeType = VkPerformanceCounterKHR;
@@ -38418,6 +45464,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceCounterKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceCounterKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, performanceCounterKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR, seed, performanceCounterKHR.unit );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR, seed, performanceCounterKHR.scope );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR, seed, performanceCounterKHR.storage );
+    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, performanceCounterKHR.uuid[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   union PerformanceCounterResultKHR
   {
     using NativeType = VkPerformanceCounterResultKHR;
@@ -38575,6 +45645,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceMarkerInfoINTEL;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceMarkerInfoINTEL.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceMarkerInfoINTEL.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, performanceMarkerInfoINTEL.marker );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PerformanceOverrideInfoINTEL
   {
     using NativeType = VkPerformanceOverrideInfoINTEL;
@@ -38685,6 +45773,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceOverrideInfoINTEL;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceOverrideInfoINTEL.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceOverrideInfoINTEL.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL, seed, performanceOverrideInfoINTEL.type );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, performanceOverrideInfoINTEL.enable );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, performanceOverrideInfoINTEL.parameter );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PerformanceQuerySubmitInfoKHR
   {
     using NativeType = VkPerformanceQuerySubmitInfoKHR;
@@ -38773,6 +45882,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceQuerySubmitInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceQuerySubmitInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceQuerySubmitInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, performanceQuerySubmitInfoKHR.counterPassIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PerformanceStreamMarkerInfoINTEL
   {
     using NativeType = VkPerformanceStreamMarkerInfoINTEL;
@@ -38860,6 +45987,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PerformanceStreamMarkerInfoINTEL;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceStreamMarkerInfoINTEL.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceStreamMarkerInfoINTEL.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, performanceStreamMarkerInfoINTEL.marker );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   union PerformanceValueDataINTEL
   {
     using NativeType = VkPerformanceValueDataINTEL;
@@ -39122,6 +46268,31 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const &
+                            physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice16BitStorageFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice16BitStorageFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storagePushConstant16 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storageInputOutput16 );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevice4444FormatsFeaturesEXT
   {
     using NativeType = VkPhysicalDevice4444FormatsFeaturesEXT;
@@ -39224,6 +46395,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevice4444FormatsFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const &
+                            physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice4444FormatsFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice4444FormatsFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevice8BitStorageFeatures
   {
     using NativeType = VkPhysicalDevice8BitStorageFeatures;
@@ -39338,6 +46528,29 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const &
+                            physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice8BitStorageFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice8BitStorageFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.storagePushConstant8 );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceASTCDecodeFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceASTCDecodeFeaturesEXT;
@@ -39430,6 +46643,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceASTCDecodeFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const &
+                            physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceASTCDecodeFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceASTCDecodeFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceAccelerationStructureFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceAccelerationStructureFeaturesKHR;
@@ -39572,6 +46804,39 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceAccelerationStructureFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const &
+                            physicalDeviceAccelerationStructureFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceAccelerationStructureFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceAccelerationStructurePropertiesKHR
   {
     using NativeType = VkPhysicalDeviceAccelerationStructurePropertiesKHR;
@@ -39681,6 +46946,41 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceAccelerationStructurePropertiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const &
+                            physicalDeviceAccelerationStructurePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceAccelerationStructurePropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t,
+      seed,
+      physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t,
+      seed,
+      physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
@@ -39777,6 +47077,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const &
+                            physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
@@ -39878,6 +47199,41 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const &
+                            physicalDeviceBlendOperationAdvancedPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceBorderColorSwizzleFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceBorderColorSwizzleFeaturesEXT;
@@ -39983,6 +47339,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceBorderColorSwizzleFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const &
+                            physicalDeviceBorderColorSwizzleFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceBufferDeviceAddressFeatures
   {
     using NativeType = VkPhysicalDeviceBufferDeviceAddressFeatures;
@@ -40100,6 +47478,30 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const &
+                            physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBufferDeviceAddressFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBufferDeviceAddressFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
@@ -40217,6 +47619,31 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const &
+                            physicalDeviceBufferDeviceAddressFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceCoherentMemoryFeaturesAMD
   {
     using NativeType = VkPhysicalDeviceCoherentMemoryFeaturesAMD;
@@ -40310,6 +47737,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCoherentMemoryFeaturesAMD;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const &
+                            physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCoherentMemoryFeaturesAMD.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceColorWriteEnableFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceColorWriteEnableFeaturesEXT;
@@ -40403,6 +47849,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceColorWriteEnableFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const &
+                            physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceColorWriteEnableFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
   {
     using NativeType = VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;
@@ -40510,6 +47976,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceComputeShaderDerivativesFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV const &
+                            physicalDeviceComputeShaderDerivativesFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceComputeShaderDerivativesFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceComputeShaderDerivativesFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupQuads );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupLinear );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceConditionalRenderingFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceConditionalRenderingFeaturesEXT;
@@ -40616,6 +48106,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceConditionalRenderingFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const &
+                            physicalDeviceConditionalRenderingFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceConditionalRenderingFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceConservativeRasterizationPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
@@ -40729,6 +48241,51 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const &
+                            physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize );
+    VULKAN_HPP_HASH_COMBINE(
+      float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize );
+    VULKAN_HPP_HASH_COMBINE(
+      float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceCooperativeMatrixFeaturesNV
   {
     using NativeType = VkPhysicalDeviceCooperativeMatrixFeaturesNV;
@@ -40834,6 +48391,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCooperativeMatrixFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const &
+                            physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCooperativeMatrixFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceCooperativeMatrixPropertiesNV
   {
     using NativeType = VkPhysicalDeviceCooperativeMatrixPropertiesNV;
@@ -40914,6 +48494,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCooperativeMatrixPropertiesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const &
+                            physicalDeviceCooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCooperativeMatrixPropertiesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags,
+                             seed,
+                             physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceCornerSampledImageFeaturesNV
   {
     using NativeType = VkPhysicalDeviceCornerSampledImageFeaturesNV;
@@ -41008,6 +48609,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCornerSampledImageFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const &
+                            physicalDeviceCornerSampledImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCornerSampledImageFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCornerSampledImageFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceCoverageReductionModeFeaturesNV
   {
     using NativeType = VkPhysicalDeviceCoverageReductionModeFeaturesNV;
@@ -41103,6 +48724,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCoverageReductionModeFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const &
+                            physicalDeviceCoverageReductionModeFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCoverageReductionModeFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceCustomBorderColorFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceCustomBorderColorFeaturesEXT;
@@ -41208,6 +48849,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCustomBorderColorFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const &
+                            physicalDeviceCustomBorderColorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCustomBorderColorFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceCustomBorderColorPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceCustomBorderColorPropertiesEXT;
@@ -41288,6 +48951,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCustomBorderColorPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const &
+                            physicalDeviceCustomBorderColorPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCustomBorderColorPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
   {
     using NativeType = VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
@@ -41388,6 +49071,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &
+                            physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDepthClipControlFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceDepthClipControlFeaturesEXT;
@@ -41481,6 +49186,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDepthClipControlFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const &
+                            physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthClipControlFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthClipControlFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDepthClipEnableFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceDepthClipEnableFeaturesEXT;
@@ -41575,6 +49300,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDepthClipEnableFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const &
+                            physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthClipEnableFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDepthStencilResolveProperties
   {
     using NativeType = VkPhysicalDeviceDepthStencilResolveProperties;
@@ -41668,6 +49413,34 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const &
+                            physicalDeviceDepthStencilResolveProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthStencilResolveProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthStencilResolveProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ResolveModeFlags,
+                             seed,
+                             physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ResolveModeFlags,
+                             seed,
+                             physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthStencilResolveProperties.independentResolve );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDescriptorIndexingFeatures
   {
     using NativeType = VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -41981,6 +49754,84 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const &
+                            physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDescriptorIndexingFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDescriptorIndexingFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDescriptorIndexingProperties
   {
     using NativeType = VkPhysicalDeviceDescriptorIndexingProperties;
@@ -42162,6 +50013,81 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const &
+                            physicalDeviceDescriptorIndexingProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDescriptorIndexingProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDescriptorIndexingProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV
   {
     using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
@@ -42258,6 +50184,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &
+                            physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV
   {
     using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
@@ -42371,6 +50317,42 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &
+                            physicalDeviceDeviceGeneratedCommandsPropertiesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDeviceMemoryReportFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceDeviceMemoryReportFeaturesEXT;
@@ -42465,6 +50447,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDeviceMemoryReportFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const &
+                            physicalDeviceDeviceMemoryReportFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDiagnosticsConfigFeaturesNV
   {
     using NativeType = VkPhysicalDeviceDiagnosticsConfigFeaturesNV;
@@ -42559,6 +50561,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDiagnosticsConfigFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const &
+                            physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDiscardRectanglePropertiesEXT
   {
     using NativeType = VkPhysicalDeviceDiscardRectanglePropertiesEXT;
@@ -42638,6 +50660,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDiscardRectanglePropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const &
+                            physicalDeviceDiscardRectanglePropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDiscardRectanglePropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDriverProperties
   {
     using NativeType = VkPhysicalDeviceDriverProperties;
@@ -42724,6 +50765,34 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDriverProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDriverProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DriverId, seed, physicalDeviceDriverProperties.driverID );
+    for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceDriverProperties.driverName[i] );
+    }
+    for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceDriverProperties.driverInfo[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ConformanceVersion, seed, physicalDeviceDriverProperties.conformanceVersion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDrmPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceDrmPropertiesEXT;
@@ -42815,6 +50884,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDrmPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDrmPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDrmPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDrmPropertiesEXT.hasPrimary );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDrmPropertiesEXT.hasRender );
+    VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.primaryMajor );
+    VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.primaryMinor );
+    VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.renderMajor );
+    VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.renderMinor );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceDynamicRenderingFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceDynamicRenderingFeaturesKHR;
@@ -42908,6 +51000,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDynamicRenderingFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeaturesKHR const &
+                            physicalDeviceDynamicRenderingFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDynamicRenderingFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDynamicRenderingFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDynamicRenderingFeaturesKHR.dynamicRendering );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceExclusiveScissorFeaturesNV
   {
     using NativeType = VkPhysicalDeviceExclusiveScissorFeaturesNV;
@@ -43001,6 +51113,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExclusiveScissorFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const &
+                            physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExclusiveScissorFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExclusiveScissorFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceExtendedDynamicState2FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;
@@ -43119,6 +51251,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExtendedDynamicState2FeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const &
+                            physicalDeviceExtendedDynamicState2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceExtendedDynamicStateFeaturesEXT;
@@ -43214,6 +51371,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExtendedDynamicStateFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const &
+                            physicalDeviceExtendedDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceExternalBufferInfo
   {
     using NativeType = VkPhysicalDeviceExternalBufferInfo;
@@ -43327,6 +51504,28 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalBufferInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalBufferInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateFlags, seed, physicalDeviceExternalBufferInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferUsageFlags, seed, physicalDeviceExternalBufferInfo.usage );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, physicalDeviceExternalBufferInfo.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceExternalFenceInfo
   {
     using NativeType = VkPhysicalDeviceExternalFenceInfo;
@@ -43419,6 +51618,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalFenceInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalFenceInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, physicalDeviceExternalFenceInfo.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceExternalImageFormatInfo
   {
     using NativeType = VkPhysicalDeviceExternalImageFormatInfo;
@@ -43514,6 +51733,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const &
+                            physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalImageFormatInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalImageFormatInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, physicalDeviceExternalImageFormatInfo.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceExternalMemoryHostPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceExternalMemoryHostPropertiesEXT;
@@ -43594,6 +51832,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExternalMemoryHostPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const &
+                            physicalDeviceExternalMemoryHostPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
+                             seed,
+                             physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceExternalMemoryRDMAFeaturesNV
   {
     using NativeType = VkPhysicalDeviceExternalMemoryRDMAFeaturesNV;
@@ -43688,6 +51947,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExternalMemoryRDMAFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const &
+                            physicalDeviceExternalMemoryRDMAFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceExternalSemaphoreInfo
   {
     using NativeType = VkPhysicalDeviceExternalSemaphoreInfo;
@@ -43782,6 +52061,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const &
+                            physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalSemaphoreInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalSemaphoreInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, physicalDeviceExternalSemaphoreInfo.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFeatures2
   {
     using NativeType = VkPhysicalDeviceFeatures2;
@@ -43869,6 +52167,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFeatures2.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFeatures2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures, seed, physicalDeviceFeatures2.features );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFloatControlsProperties
   {
     using NativeType = VkPhysicalDeviceFloatControlsProperties;
@@ -44016,6 +52332,59 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const &
+                            physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFloatControlsProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFloatControlsProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
+                             seed,
+                             physicalDeviceFloatControlsProperties.denormBehaviorIndependence );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
+                             seed,
+                             physicalDeviceFloatControlsProperties.roundingModeIndependence );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFragmentDensityMap2FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceFragmentDensityMap2FeaturesEXT;
@@ -44111,6 +52480,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentDensityMap2FeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const &
+                            physicalDeviceFragmentDensityMap2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFragmentDensityMap2PropertiesEXT
   {
     using NativeType = VkPhysicalDeviceFragmentDensityMap2PropertiesEXT;
@@ -44202,6 +52591,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentDensityMap2PropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const &
+                            physicalDeviceFragmentDensityMap2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFragmentDensityMapFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
@@ -44318,6 +52733,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const &
+                            physicalDeviceFragmentDensityMapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFragmentDensityMapPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceFragmentDensityMapPropertiesEXT;
@@ -44406,6 +52846,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentDensityMapPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const &
+                            physicalDeviceFragmentDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
   {
     using NativeType = VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;
@@ -44503,6 +52967,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV const &
+                            physicalDeviceFragmentShaderBarycentricFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.fragmentShaderBarycentric );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
@@ -44621,6 +53105,33 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const &
+                            physicalDeviceFragmentShaderInterlockFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV
   {
     using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
@@ -44739,6 +53250,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &
+                            physicalDeviceFragmentShadingRateEnumsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV
   {
     using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
@@ -44839,6 +53376,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &
+                            physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits,
+                             seed,
+                             physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFragmentShadingRateFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceFragmentShadingRateFeaturesKHR;
@@ -44956,6 +53514,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShadingRateFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const &
+                            physicalDeviceFragmentShadingRateFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFragmentShadingRateKHR
   {
     using NativeType = VkPhysicalDeviceFragmentShadingRateKHR;
@@ -45036,6 +53618,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShadingRateKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const &
+                            physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceFragmentShadingRateKHR.sampleCounts );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentShadingRateKHR.fragmentSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceFragmentShadingRatePropertiesKHR
   {
     using NativeType = VkPhysicalDeviceFragmentShadingRatePropertiesKHR;
@@ -45186,6 +53788,79 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFragmentShadingRatePropertiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const &
+                            physicalDeviceFragmentShadingRatePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D,
+                             seed,
+                             physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D,
+                             seed,
+                             physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t,
+      seed,
+      physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlagBits,
+      seed,
+      physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceGlobalPriorityQueryFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT;
@@ -45280,6 +53955,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceGlobalPriorityQueryFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT const &
+                            physicalDeviceGlobalPriorityQueryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.globalPriorityQuery );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceGroupProperties
   {
     using NativeType = VkPhysicalDeviceGroupProperties;
@@ -45363,6 +54058,30 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceGroupProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceGroupProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceGroupProperties.physicalDeviceCount );
+    for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE(
+        VULKAN_HPP_NAMESPACE::PhysicalDevice, seed, physicalDeviceGroupProperties.physicalDevices[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceGroupProperties.subsetAllocation );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceHostQueryResetFeatures
   {
     using NativeType = VkPhysicalDeviceHostQueryResetFeatures;
@@ -45455,6 +54174,24 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const &
+                            physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceHostQueryResetFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceHostQueryResetFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceHostQueryResetFeatures.hostQueryReset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceIDProperties
   {
     using NativeType = VkPhysicalDeviceIDProperties;
@@ -45542,6 +54279,37 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceIDProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceIDProperties.pNext );
+    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.deviceUUID[i] );
+    }
+    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.driverUUID[i] );
+    }
+    for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.deviceLUID[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceIDProperties.deviceNodeMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceIDProperties.deviceLUIDValid );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceImageDrmFormatModifierInfoEXT
   {
     using NativeType = VkPhysicalDeviceImageDrmFormatModifierInfoEXT;
@@ -45691,6 +54459,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceImageDrmFormatModifierInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const &
+                            physicalDeviceImageDrmFormatModifierInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SharingMode, seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceImageFormatInfo2
   {
     using NativeType = VkPhysicalDeviceImageFormatInfo2;
@@ -45822,6 +54613,28 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageFormatInfo2.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceImageFormatInfo2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, physicalDeviceImageFormatInfo2.format );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, physicalDeviceImageFormatInfo2.type );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, physicalDeviceImageFormatInfo2.tiling );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceImageFormatInfo2.usage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, physicalDeviceImageFormatInfo2.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceImageRobustnessFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceImageRobustnessFeaturesEXT;
@@ -45916,6 +54729,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceImageRobustnessFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeaturesEXT const &
+                            physicalDeviceImageRobustnessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageRobustnessFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageRobustnessFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImageRobustnessFeaturesEXT.robustImageAccess );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceImageViewImageFormatInfoEXT
   {
     using NativeType = VkPhysicalDeviceImageViewImageFormatInfoEXT;
@@ -46011,6 +54844,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceImageViewImageFormatInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const &
+                            physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageViewImageFormatInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageViewImageFormatInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageViewType, seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceImageViewMinLodFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceImageViewMinLodFeaturesEXT;
@@ -46105,6 +54958,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceImageViewMinLodFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const &
+                            physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageViewMinLodFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceImagelessFramebufferFeatures
   {
     using NativeType = VkPhysicalDeviceImagelessFramebufferFeatures;
@@ -46200,6 +55072,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const &
+                            physicalDeviceImagelessFramebufferFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImagelessFramebufferFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImagelessFramebufferFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceIndexTypeUint8FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
@@ -46293,6 +55185,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceIndexTypeUint8FeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const &
+                            physicalDeviceIndexTypeUint8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceIndexTypeUint8FeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceIndexTypeUint8FeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceInheritedViewportScissorFeaturesNV
   {
     using NativeType = VkPhysicalDeviceInheritedViewportScissorFeaturesNV;
@@ -46389,6 +55300,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceInheritedViewportScissorFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const &
+                            physicalDeviceInheritedViewportScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceInlineUniformBlockFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceInlineUniformBlockFeaturesEXT;
@@ -46496,6 +55427,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceInlineUniformBlockFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeaturesEXT const &
+                            physicalDeviceInlineUniformBlockFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInlineUniformBlockFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInlineUniformBlockFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInlineUniformBlockFeaturesEXT.inlineUniformBlock );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceInlineUniformBlockFeaturesEXT.descriptorBindingInlineUniformBlockUpdateAfterBind );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceInlineUniformBlockPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceInlineUniformBlockPropertiesEXT;
@@ -46595,6 +55550,37 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceInlineUniformBlockPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockPropertiesEXT const &
+                            physicalDeviceInlineUniformBlockPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInlineUniformBlockPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInlineUniformBlockPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxInlineUniformBlockSize );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxPerStageDescriptorInlineUniformBlocks );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t,
+      seed,
+      physicalDeviceInlineUniformBlockPropertiesEXT.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxDescriptorSetInlineUniformBlocks );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t,
+      seed,
+      physicalDeviceInlineUniformBlockPropertiesEXT.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceInvocationMaskFeaturesHUAWEI
   {
     using NativeType = VkPhysicalDeviceInvocationMaskFeaturesHUAWEI;
@@ -46688,6 +55674,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceInvocationMaskFeaturesHUAWEI;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const &
+                            physicalDeviceInvocationMaskFeaturesHUAWEI ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceLimits
   {
     using NativeType = VkPhysicalDeviceLimits;
@@ -47160,6 +56166,159 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits>::value,
                             "PhysicalDeviceLimits is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension1D );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension2D );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension3D );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimensionCube );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageArrayLayers );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelBufferElements );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxUniformBufferRange );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxStorageBufferRange );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPushConstantsSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxMemoryAllocationCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxSamplerAllocationCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.bufferImageGranularity );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.sparseAddressSpaceSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxBoundDescriptorSets );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorSamplers );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageResources );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetSamplers );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetSampledImages );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageImages );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetInputAttachments );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputAttributes );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputBindings );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputAttributeOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputBindingStride );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexOutputComponents );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationGenerationLevel );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationPatchSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryShaderInvocations );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryInputComponents );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryOutputComponents );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryOutputVertices );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryTotalOutputComponents );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentInputComponents );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentOutputAttachments );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentDualSrcAttachments );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentCombinedOutputResources );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeSharedMemorySize );
+    for ( size_t i = 0; i < 3; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupInvocations );
+    for ( size_t i = 0; i < 3; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subPixelPrecisionBits );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subTexelPrecisionBits );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.mipmapPrecisionBits );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDrawIndexedIndexValue );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDrawIndirectCount );
+    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxSamplerLodBias );
+    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxSamplerAnisotropy );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxViewports );
+    for ( size_t i = 0; i < 2; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxViewportDimensions[i] );
+    }
+    for ( size_t i = 0; i < 2; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.viewportBoundsRange[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.viewportSubPixelBits );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, physicalDeviceLimits.minMemoryMapAlignment );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minTexelBufferOffsetAlignment );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minUniformBufferOffsetAlignment );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minStorageBufferOffsetAlignment );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, physicalDeviceLimits.minTexelOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelOffset );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, physicalDeviceLimits.minTexelGatherOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelGatherOffset );
+    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.minInterpolationOffset );
+    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxInterpolationOffset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subPixelInterpolationOffsetBits );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferWidth );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferHeight );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferLayers );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferColorSampleCounts );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferDepthSampleCounts );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferStencilSampleCounts );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxColorAttachments );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageColorSampleCounts );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageIntegerSampleCounts );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageDepthSampleCounts );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageStencilSampleCounts );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.storageImageSampleCounts );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxSampleMaskWords );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.timestampComputeAndGraphics );
+    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.timestampPeriod );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxClipDistances );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxCullDistances );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxCombinedClipAndCullDistances );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.discreteQueuePriorities );
+    for ( size_t i = 0; i < 2; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.pointSizeRange[i] );
+    }
+    for ( size_t i = 0; i < 2; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.lineWidthRange[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.pointSizeGranularity );
+    VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.lineWidthGranularity );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.strictLines );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.standardSampleLocations );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.nonCoherentAtomSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceLineRasterizationFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceLineRasterizationFeaturesEXT;
@@ -47308,6 +56467,36 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceLineRasterizationFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const &
+                            physicalDeviceLineRasterizationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceLineRasterizationFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceLineRasterizationFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.rectangularLines );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.smoothLines );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceLineRasterizationPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceLineRasterizationPropertiesEXT;
@@ -47388,6 +56577,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceLineRasterizationPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const &
+                            physicalDeviceLineRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceLineRasterizationPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceLineRasterizationPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLineRasterizationPropertiesEXT.lineSubPixelPrecisionBits );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMaintenance3Properties
   {
     using NativeType = VkPhysicalDeviceMaintenance3Properties;
@@ -47469,6 +56677,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const &
+                            physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance3Properties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance3Properties.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMaintenance4FeaturesKHR
   {
     using NativeType = VkPhysicalDeviceMaintenance4FeaturesKHR;
@@ -47561,6 +56789,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMaintenance4FeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4FeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4FeaturesKHR const &
+                            physicalDeviceMaintenance4FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance4FeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance4FeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMaintenance4FeaturesKHR.maintenance4 );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMaintenance4PropertiesKHR
   {
     using NativeType = VkPhysicalDeviceMaintenance4PropertiesKHR;
@@ -47638,6 +56884,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMaintenance4PropertiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4PropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4PropertiesKHR const &
+                            physicalDeviceMaintenance4PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance4PropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance4PropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMaintenance4PropertiesKHR.maxBufferSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMemoryBudgetPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceMemoryBudgetPropertiesEXT;
@@ -47720,6 +56985,33 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMemoryBudgetPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const &
+                            physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryBudgetPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext );
+    for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE(
+        VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] );
+    }
+    for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE(
+        VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMemoryPriorityFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceMemoryPriorityFeaturesEXT;
@@ -47813,6 +57105,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMemoryPriorityFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const &
+                            physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryPriorityFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMemoryProperties
   {
     using NativeType = VkPhysicalDeviceMemoryProperties;
@@ -47886,6 +57197,31 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties>::value,
     "PhysicalDeviceMemoryProperties is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMemoryProperties.memoryTypeCount );
+    for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryType, seed, physicalDeviceMemoryProperties.memoryTypes[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMemoryProperties.memoryHeapCount );
+    for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryHeap, seed, physicalDeviceMemoryProperties.memoryHeaps[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMemoryProperties2
   {
     using NativeType = VkPhysicalDeviceMemoryProperties2;
@@ -47961,6 +57297,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryProperties2.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryProperties2.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties, seed, physicalDeviceMemoryProperties2.memoryProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMeshShaderFeaturesNV
   {
     using NativeType = VkPhysicalDeviceMeshShaderFeaturesNV;
@@ -48063,6 +57419,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMeshShaderFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const &
+                            physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMeshShaderFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMeshShaderFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMeshShaderFeaturesNV.taskShader );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMeshShaderFeaturesNV.meshShader );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMeshShaderPropertiesNV
   {
     using NativeType = VkPhysicalDeviceMeshShaderPropertiesNV;
@@ -48188,6 +57563,42 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMeshShaderPropertiesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const &
+                            physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMeshShaderPropertiesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMeshShaderPropertiesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations );
+    for ( size_t i = 0; i < 3; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations );
+    for ( size_t i = 0; i < 3; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMultiDrawFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceMultiDrawFeaturesEXT;
@@ -48279,6 +57690,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMultiDrawFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const &
+                            physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiDrawFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiDrawFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMultiDrawPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceMultiDrawPropertiesEXT;
@@ -48354,6 +57783,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMultiDrawPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const &
+                            physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiDrawPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiDrawPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMultiviewFeatures
   {
     using NativeType = VkPhysicalDeviceMultiviewFeatures;
@@ -48466,6 +57913,29 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiview );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
   {
     using NativeType = VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
@@ -48548,6 +58018,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &
+                            physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMultiviewProperties
   {
     using NativeType = VkPhysicalDeviceMultiviewProperties;
@@ -48629,6 +58120,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const &
+                            physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
   {
     using NativeType = VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
@@ -48724,6 +58234,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &
+                            physicalDeviceMutableDescriptorTypeFeaturesVALVE ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.mutableDescriptorType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevicePCIBusInfoPropertiesEXT
   {
     using NativeType = VkPhysicalDevicePCIBusInfoPropertiesEXT;
@@ -48810,6 +58340,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePCIBusInfoPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const &
+                            physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePCIBusInfoPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePCIBusInfoPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT
   {
     using NativeType = VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
@@ -48907,6 +58458,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &
+                            physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevicePerformanceQueryFeaturesKHR
   {
     using NativeType = VkPhysicalDevicePerformanceQueryFeaturesKHR;
@@ -49013,6 +58585,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePerformanceQueryFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const &
+                            physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePerformanceQueryFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePerformanceQueryFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevicePerformanceQueryPropertiesKHR
   {
     using NativeType = VkPhysicalDevicePerformanceQueryPropertiesKHR;
@@ -49093,6 +58688,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePerformanceQueryPropertiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const &
+                            physicalDevicePerformanceQueryPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePerformanceQueryPropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePerformanceQueryPropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT
   {
     using NativeType = VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT;
@@ -49191,6 +58806,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeaturesEXT const &
+                            physicalDevicePipelineCreationCacheControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePipelineCreationCacheControlFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePipelineCreationCacheControlFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDevicePipelineCreationCacheControlFeaturesEXT.pipelineCreationCacheControl );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
   {
     using NativeType = VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
@@ -49289,6 +58925,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &
+                            physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevicePointClippingProperties
   {
     using NativeType = VkPhysicalDevicePointClippingProperties;
@@ -49369,6 +59026,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const &
+                            physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePointClippingProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePointClippingProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PointClippingBehavior, seed, physicalDevicePointClippingProperties.pointClippingBehavior );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   struct PhysicalDevicePortabilitySubsetFeaturesKHR
   {
@@ -49615,6 +59291,56 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = PhysicalDevicePortabilitySubsetFeaturesKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const &
+                            physicalDevicePortabilitySubsetFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePortabilitySubsetFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.events );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -49712,6 +59438,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = PhysicalDevicePortabilitySubsetPropertiesKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const &
+                            physicalDevicePortabilitySubsetPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePortabilitySubsetPropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct PhysicalDevicePresentIdFeaturesKHR
@@ -49805,6 +59552,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePresentIdFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const &
+                            physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePresentIdFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePresentIdFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePresentIdFeaturesKHR.presentId );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevicePresentWaitFeaturesKHR
   {
     using NativeType = VkPhysicalDevicePresentWaitFeaturesKHR;
@@ -49896,6 +59661,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePresentWaitFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const &
+                            physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePresentWaitFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePresentWaitFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePresentWaitFeaturesKHR.presentWait );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
   {
     using NativeType = VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
@@ -50006,6 +59789,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &
+                            physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevicePrivateDataFeaturesEXT
   {
     using NativeType = VkPhysicalDevicePrivateDataFeaturesEXT;
@@ -50097,6 +59904,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePrivateDataFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeaturesEXT const &
+                            physicalDevicePrivateDataFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePrivateDataFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePrivateDataFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePrivateDataFeaturesEXT.privateData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSparseProperties
   {
     using NativeType = VkPhysicalDeviceSparseProperties;
@@ -50176,6 +60001,31 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>::value,
     "PhysicalDeviceSparseProperties is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyAlignedMipSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyNonResidentStrict );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceProperties
   {
     using NativeType = VkPhysicalDeviceProperties;
@@ -50264,6 +60114,37 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>::value,
                             "PhysicalDeviceProperties is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.apiVersion );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.driverVersion );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.vendorID );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.deviceID );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceType, seed, physicalDeviceProperties.deviceType );
+    for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceProperties.deviceName[i] );
+    }
+    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceProperties.pipelineCacheUUID[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits, seed, physicalDeviceProperties.limits );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties, seed, physicalDeviceProperties.sparseProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceProperties2
   {
     using NativeType = VkPhysicalDeviceProperties2;
@@ -50337,6 +60218,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProperties2.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProperties2.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties, seed, physicalDeviceProperties2.properties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceProtectedMemoryFeatures
   {
     using NativeType = VkPhysicalDeviceProtectedMemoryFeatures;
@@ -50429,6 +60329,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceProtectedMemoryFeatures;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const &
+                            physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProtectedMemoryFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProtectedMemoryFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProtectedMemoryFeatures.protectedMemory );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceProtectedMemoryProperties
   {
     using NativeType = VkPhysicalDeviceProtectedMemoryProperties;
@@ -50507,6 +60426,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceProtectedMemoryProperties;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const &
+                            physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProtectedMemoryProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProtectedMemoryProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProtectedMemoryProperties.protectedNoFault );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceProvokingVertexFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceProvokingVertexFeaturesEXT;
@@ -50612,6 +60550,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceProvokingVertexFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const &
+                            physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProvokingVertexFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProvokingVertexFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceProvokingVertexPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceProvokingVertexPropertiesEXT;
@@ -50697,6 +60658,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceProvokingVertexPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const &
+                            physicalDeviceProvokingVertexPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProvokingVertexPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProvokingVertexPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDevicePushDescriptorPropertiesKHR
   {
     using NativeType = VkPhysicalDevicePushDescriptorPropertiesKHR;
@@ -50776,6 +60761,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePushDescriptorPropertiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR const &
+                            physicalDevicePushDescriptorPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePushDescriptorPropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePushDescriptorPropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT;
@@ -50871,6 +60875,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const &
+                            physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM
   {
     using NativeType = VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
@@ -50997,6 +61021,36 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const &
+                            physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderColorAttachmentAccess );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderDepthAttachmentAccess );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderStencilAttachmentAccess );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceRayQueryFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceRayQueryFeaturesKHR;
@@ -51087,6 +61141,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRayQueryFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const &
+                            physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayQueryFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayQueryFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayQueryFeaturesKHR.rayQuery );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceRayTracingMotionBlurFeaturesNV
   {
     using NativeType = VkPhysicalDeviceRayTracingMotionBlurFeaturesNV;
@@ -51193,6 +61265,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRayTracingMotionBlurFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const &
+                            physicalDeviceRayTracingMotionBlurFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceRayTracingPipelineFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceRayTracingPipelineFeaturesKHR;
@@ -51335,6 +61431,39 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRayTracingPipelineFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const &
+                            physicalDeviceRayTracingPipelineFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceRayTracingPipelinePropertiesKHR
   {
     using NativeType = VkPhysicalDeviceRayTracingPipelinePropertiesKHR;
@@ -51443,6 +61572,34 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRayTracingPipelinePropertiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const &
+                            physicalDeviceRayTracingPipelinePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceRayTracingPropertiesNV
   {
     using NativeType = VkPhysicalDeviceRayTracingPropertiesNV;
@@ -51546,6 +61703,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRayTracingPropertiesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const &
+                            physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPropertiesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPropertiesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
   {
     using NativeType = VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;
@@ -51643,6 +61826,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const &
+                            physicalDeviceRepresentativeFragmentTestFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceRobustness2FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceRobustness2FeaturesEXT;
@@ -51755,6 +61959,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRobustness2FeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const &
+                            physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRobustness2FeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRobustness2FeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceRobustness2PropertiesEXT
   {
     using NativeType = VkPhysicalDeviceRobustness2PropertiesEXT;
@@ -51838,6 +62064,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRobustness2PropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const &
+                            physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRobustness2PropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRobustness2PropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
+                             seed,
+                             physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
+                             seed,
+                             physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSampleLocationsPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceSampleLocationsPropertiesEXT;
@@ -51934,6 +62183,37 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSampleLocationsPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const &
+                            physicalDeviceSampleLocationsPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSampleLocationsPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSampleLocationsPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags,
+                             seed,
+                             physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize );
+    for ( size_t i = 0; i < 2; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE(
+        float, seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSamplerFilterMinmaxProperties
   {
     using NativeType = VkPhysicalDeviceSamplerFilterMinmaxProperties;
@@ -52019,6 +62299,30 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const &
+                            physicalDeviceSamplerFilterMinmaxProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSamplerFilterMinmaxProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSamplerFilterMinmaxProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSamplerYcbcrConversionFeatures
   {
     using NativeType = VkPhysicalDeviceSamplerYcbcrConversionFeatures;
@@ -52115,6 +62419,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const &
+                            physicalDeviceSamplerYcbcrConversionFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSamplerYcbcrConversionFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceScalarBlockLayoutFeatures
   {
     using NativeType = VkPhysicalDeviceScalarBlockLayoutFeatures;
@@ -52208,6 +62532,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const &
+                            physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceScalarBlockLayoutFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceScalarBlockLayoutFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures
   {
     using NativeType = VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;
@@ -52306,6 +62649,27 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const &
+                            physicalDeviceSeparateDepthStencilLayoutsFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -52522,6 +62886,48 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const &
+                            physicalDeviceShaderAtomicFloat2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderAtomicFloatFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -52738,6 +63144,48 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderAtomicFloatFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const &
+                            physicalDeviceShaderAtomicFloatFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderAtomicInt64Features
   {
     using NativeType = VkPhysicalDeviceShaderAtomicInt64Features;
@@ -52844,6 +63292,27 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const &
+                            physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicInt64Features.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicInt64Features.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderClockFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceShaderClockFeaturesKHR;
@@ -52946,6 +63415,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderClockFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const &
+                            physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderClockFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderClockFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderCoreProperties2AMD
   {
     using NativeType = VkPhysicalDeviceShaderCoreProperties2AMD;
@@ -53028,6 +63518,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderCoreProperties2AMD;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const &
+                            physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderCoreProperties2AMD.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderCoreProperties2AMD.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD,
+                             seed,
+                             physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderCorePropertiesAMD
   {
     using NativeType = VkPhysicalDeviceShaderCorePropertiesAMD;
@@ -53152,6 +63663,37 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderCorePropertiesAMD;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const &
+                            physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderCorePropertiesAMD.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderCorePropertiesAMD.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
@@ -53250,6 +63792,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const &
+                            physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.shaderDemoteToHelperInvocation );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderDrawParametersFeatures
   {
     using NativeType = VkPhysicalDeviceShaderDrawParametersFeatures;
@@ -53345,6 +63908,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const &
+                            physicalDeviceShaderDrawParametersFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderDrawParametersFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderDrawParametersFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderFloat16Int8Features
   {
     using NativeType = VkPhysicalDeviceShaderFloat16Int8Features;
@@ -53451,6 +64034,26 @@ namespace VULKAN_HPP_NAMESPACE
   using PhysicalDeviceFloat16Int8FeaturesKHR       = PhysicalDeviceShaderFloat16Int8Features;
   using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const &
+                            physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderFloat16Int8Features.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderFloat16Int8Features.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT
   {
     using NativeType = VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
@@ -53558,6 +64161,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &
+                            physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderImageFootprintFeaturesNV
   {
     using NativeType = VkPhysicalDeviceShaderImageFootprintFeaturesNV;
@@ -53651,6 +64276,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderImageFootprintFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const &
+                            physicalDeviceShaderImageFootprintFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderImageFootprintFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderIntegerDotProductFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR;
@@ -53747,6 +64392,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderIntegerDotProductFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeaturesKHR const &
+                            physicalDeviceShaderIntegerDotProductFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.shaderIntegerDotProduct );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderIntegerDotProductPropertiesKHR
   {
     using NativeType = VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR;
@@ -54261,6 +64926,144 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderIntegerDotProductPropertiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductPropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductPropertiesKHR const &
+                            physicalDeviceShaderIntegerDotProductPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerDotProductPropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerDotProductPropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitUnsignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitSignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitMixedSignednessAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedUnsignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedSignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedMixedSignednessAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitUnsignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitSignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitMixedSignednessAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitUnsignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitSignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitMixedSignednessAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitUnsignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitSignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitMixedSignednessAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating8BitUnsignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProductAccumulatingSaturating8BitSignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating16BitUnsignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating16BitSignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating32BitUnsignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating32BitSignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating64BitUnsignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating64BitSignedAccelerated );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderIntegerDotProductPropertiesKHR
+                               .integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
   {
     using NativeType = VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
@@ -54358,6 +65161,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &
+                            physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV
   {
     using NativeType = VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;
@@ -54451,6 +65274,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderSMBuiltinsFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const &
+                            physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV
   {
     using NativeType = VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;
@@ -54534,6 +65377,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const &
+                            physicalDeviceShaderSMBuiltinsPropertiesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures
   {
     using NativeType = VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;
@@ -54632,6 +65495,27 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const &
+                            physicalDeviceShaderSubgroupExtendedTypesFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
@@ -54733,6 +65617,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &
+                            physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShaderTerminateInvocationFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR;
@@ -54830,6 +65736,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeaturesKHR const &
+                            physicalDeviceShaderTerminateInvocationFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderTerminateInvocationFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderTerminateInvocationFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceShaderTerminateInvocationFeaturesKHR.shaderTerminateInvocation );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShadingRateImageFeaturesNV
   {
     using NativeType = VkPhysicalDeviceShadingRateImageFeaturesNV;
@@ -54935,6 +65862,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShadingRateImageFeaturesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const &
+                            physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShadingRateImageFeaturesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShadingRateImageFeaturesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceShadingRateImagePropertiesNV
   {
     using NativeType = VkPhysicalDeviceShadingRateImagePropertiesNV;
@@ -55022,6 +65971,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceShadingRateImagePropertiesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const &
+                            physicalDeviceShadingRateImagePropertiesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShadingRateImagePropertiesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShadingRateImagePropertiesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSparseImageFormatInfo2
   {
     using NativeType = VkPhysicalDeviceSparseImageFormatInfo2;
@@ -55155,6 +66126,29 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const &
+                            physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSparseImageFormatInfo2.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceSparseImageFormatInfo2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, physicalDeviceSparseImageFormatInfo2.format );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, physicalDeviceSparseImageFormatInfo2.type );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, physicalDeviceSparseImageFormatInfo2.samples );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceSparseImageFormatInfo2.usage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, physicalDeviceSparseImageFormatInfo2.tiling );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSubgroupProperties
   {
     using NativeType = VkPhysicalDeviceSubgroupProperties;
@@ -55240,6 +66234,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSubgroupProperties;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupProperties.subgroupSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, physicalDeviceSubgroupProperties.supportedStages );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags, seed, physicalDeviceSubgroupProperties.supportedOperations );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSubgroupSizeControlFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;
@@ -55345,6 +66364,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSubgroupSizeControlFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeaturesEXT const &
+                            physicalDeviceSubgroupSizeControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.subgroupSizeControl );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.computeFullSubgroups );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSubgroupSizeControlPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;
@@ -55436,6 +66477,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSubgroupSizeControlPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlPropertiesEXT const &
+                            physicalDeviceSubgroupSizeControlPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.minSubgroupSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.maxSubgroupSize );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.maxComputeWorkgroupSubgroups );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags,
+                             seed,
+                             physicalDeviceSubgroupSizeControlPropertiesEXT.requiredSubgroupSizeStages );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSubpassShadingFeaturesHUAWEI
   {
     using NativeType = VkPhysicalDeviceSubpassShadingFeaturesHUAWEI;
@@ -55529,6 +66595,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSubpassShadingFeaturesHUAWEI;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const &
+                            physicalDeviceSubpassShadingFeaturesHUAWEI ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSubpassShadingPropertiesHUAWEI
   {
     using NativeType = VkPhysicalDeviceSubpassShadingPropertiesHUAWEI;
@@ -55609,6 +66695,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSubpassShadingPropertiesHUAWEI;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const &
+                            physicalDeviceSubpassShadingPropertiesHUAWEI ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSurfaceInfo2KHR
   {
     using NativeType = VkPhysicalDeviceSurfaceInfo2KHR;
@@ -55698,6 +66804,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSurfaceInfo2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSurfaceInfo2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceSurfaceInfo2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceKHR, seed, physicalDeviceSurfaceInfo2KHR.surface );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceSynchronization2FeaturesKHR
   {
     using NativeType = VkPhysicalDeviceSynchronization2FeaturesKHR;
@@ -55791,6 +66915,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSynchronization2FeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2FeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2FeaturesKHR const &
+                            physicalDeviceSynchronization2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSynchronization2FeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSynchronization2FeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSynchronization2FeaturesKHR.synchronization2 );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;
@@ -55886,6 +67030,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const &
+                            physicalDeviceTexelBufferAlignmentFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;
@@ -55978,6 +67142,38 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentPropertiesEXT const &
+                            physicalDeviceTexelBufferAlignmentPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTexelBufferAlignmentPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTexelBufferAlignmentPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
+                             seed,
+                             physicalDeviceTexelBufferAlignmentPropertiesEXT.storageTexelBufferOffsetAlignmentBytes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceTexelBufferAlignmentPropertiesEXT.storageTexelBufferOffsetSingleTexelAlignment );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
+                             seed,
+                             physicalDeviceTexelBufferAlignmentPropertiesEXT.uniformTexelBufferOffsetAlignmentBytes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceTexelBufferAlignmentPropertiesEXT.uniformTexelBufferOffsetSingleTexelAlignment );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
@@ -56075,6 +67271,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const &
+                            physicalDeviceTextureCompressionASTCHDRFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTextureCompressionASTCHDRFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTextureCompressionASTCHDRFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceTextureCompressionASTCHDRFeaturesEXT.textureCompressionASTC_HDR );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceTimelineSemaphoreFeatures
   {
     using NativeType = VkPhysicalDeviceTimelineSemaphoreFeatures;
@@ -56168,6 +67385,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const &
+                            physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTimelineSemaphoreFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTimelineSemaphoreFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceTimelineSemaphoreProperties
   {
     using NativeType = VkPhysicalDeviceTimelineSemaphoreProperties;
@@ -56248,6 +67484,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const &
+                            physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTimelineSemaphoreProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTimelineSemaphoreProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint64_t, seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceToolPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceToolPropertiesEXT;
@@ -56335,6 +67591,42 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceToolPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT const & physicalDeviceToolPropertiesEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceToolPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceToolPropertiesEXT.pNext );
+    for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.name[i] );
+    }
+    for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.version[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT, seed, physicalDeviceToolPropertiesEXT.purposes );
+    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.description[i] );
+    }
+    for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.layer[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceTransformFeedbackFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceTransformFeedbackFeaturesEXT;
@@ -56440,6 +67732,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceTransformFeedbackFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const &
+                            physicalDeviceTransformFeedbackFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTransformFeedbackFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceTransformFeedbackPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceTransformFeedbackPropertiesEXT;
@@ -56556,6 +67870,45 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceTransformFeedbackPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const &
+                            physicalDeviceTransformFeedbackPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTransformFeedbackPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
+                             seed,
+                             physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceUniformBufferStandardLayoutFeatures
   {
     using NativeType = VkPhysicalDeviceUniformBufferStandardLayoutFeatures;
@@ -56654,6 +68007,27 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const &
+                            physicalDeviceUniformBufferStandardLayoutFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceVariablePointersFeatures
   {
     using NativeType = VkPhysicalDeviceVariablePointersFeatures;
@@ -56762,6 +68136,27 @@ namespace VULKAN_HPP_NAMESPACE
   using PhysicalDeviceVariablePointerFeaturesKHR  = PhysicalDeviceVariablePointersFeatures;
   using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const &
+                            physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVariablePointersFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVariablePointersFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVariablePointersFeatures.variablePointers );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
@@ -56869,6 +68264,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const &
+                            physicalDeviceVertexAttributeDivisorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateDivisor );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateZeroDivisor );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
   {
     using NativeType = VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
@@ -56950,6 +68369,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const &
+                            physicalDeviceVertexAttributeDivisorPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT;
@@ -57046,6 +68484,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const &
+                            physicalDeviceVertexInputDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   struct VideoProfileKHR
   {
@@ -57165,6 +68623,30 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoProfileKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoProfileKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileKHR const & videoProfileKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoProfileKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, videoProfileKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR, seed, videoProfileKHR.videoCodecOperation );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR, seed, videoProfileKHR.chromaSubsampling );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR, seed, videoProfileKHR.lumaBitDepth );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR, seed, videoProfileKHR.chromaBitDepth );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -57262,6 +68744,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoProfilesKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoProfilesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfilesKHR const & videoProfilesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoProfilesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, videoProfilesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoProfilesKHR.profileCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoProfileKHR *, seed, videoProfilesKHR.pProfiles );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -57342,6 +68843,28 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = PhysicalDeviceVideoFormatInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVideoFormatInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVideoFormatInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceVideoFormatInfoKHR.imageUsage );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::VideoProfilesKHR *, seed, physicalDeviceVideoFormatInfoKHR.pVideoProfiles );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct PhysicalDeviceVulkan11Features
@@ -57553,6 +69076,41 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVulkan11Features;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan11Features.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan11Features.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storagePushConstant16 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storageInputOutput16 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiview );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiviewGeometryShader );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiviewTessellationShader );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.variablePointers );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.protectedMemory );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.samplerYcbcrConversion );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.shaderDrawParameters );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceVulkan11Properties
   {
     using NativeType = VkPhysicalDeviceVulkan11Properties;
@@ -57681,6 +69239,53 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVulkan11Properties;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan11Properties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan11Properties.pNext );
+    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.deviceUUID[i] );
+    }
+    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.driverUUID[i] );
+    }
+    for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.deviceLUID[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.deviceNodeMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.deviceLUIDValid );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.subgroupSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, physicalDeviceVulkan11Properties.subgroupSupportedStages );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags, seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PointClippingBehavior, seed, physicalDeviceVulkan11Properties.pointClippingBehavior );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.protectedNoFault );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceVulkan12Features
   {
     using NativeType = VkPhysicalDeviceVulkan12Features;
@@ -58277,6 +69882,111 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVulkan12Features;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan12Features.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan12Features.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.drawIndirectCount );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.storagePushConstant8 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderFloat16 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInt8 );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorIndexing );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.runtimeDescriptorArray );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.samplerFilterMinmax );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.scalarBlockLayout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.imagelessFramebuffer );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.hostQueryReset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.timelineSemaphore );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddress );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.vulkanMemoryModel );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderOutputLayer );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceVulkan12Properties
   {
     using NativeType = VkPhysicalDeviceVulkan12Properties;
@@ -58571,6 +70281,134 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceVulkan12Properties;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan12Properties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan12Properties.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DriverId, seed, physicalDeviceVulkan12Properties.driverID );
+    for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceVulkan12Properties.driverName[i] );
+    }
+    for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceVulkan12Properties.driverInfo[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ConformanceVersion, seed, physicalDeviceVulkan12Properties.conformanceVersion );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
+                             seed,
+                             physicalDeviceVulkan12Properties.denormBehaviorIndependence );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
+                             seed,
+                             physicalDeviceVulkan12Properties.roundingModeIndependence );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ResolveModeFlags, seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ResolveModeFlags, seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.independentResolveNone );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.independentResolve );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags,
+                             seed,
+                             physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceVulkanMemoryModelFeatures
   {
     using NativeType = VkPhysicalDeviceVulkanMemoryModelFeatures;
@@ -58687,6 +70525,30 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const &
+                            physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkanMemoryModelFeatures.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkanMemoryModelFeatures.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
@@ -58821,6 +70683,39 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &
+                            physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
@@ -58916,6 +70811,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &
+                            physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceYcbcrImageArraysFeaturesEXT
   {
     using NativeType = VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;
@@ -59009,6 +70924,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const &
+                            physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
@@ -59108,6 +71043,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const &
+                            physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32,
+      seed,
+      physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.shaderZeroInitializeWorkgroupMemory );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineCacheCreateInfo
   {
     using NativeType = VkPipelineCacheCreateInfo;
@@ -59231,6 +71188,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCacheCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCacheCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCacheCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags, seed, pipelineCacheCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, pipelineCacheCreateInfo.initialDataSize );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCacheCreateInfo.pInitialData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineCacheHeaderVersionOne
   {
     using NativeType = VkPipelineCacheHeaderVersionOne;
@@ -59344,6 +71321,30 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>::value,
     "PipelineCacheHeaderVersionOne is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.headerSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion, seed, pipelineCacheHeaderVersionOne.headerVersion );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.vendorID );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.deviceID );
+    for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint8_t, seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineColorBlendAdvancedStateCreateInfoEXT
   {
     using NativeType = VkPipelineColorBlendAdvancedStateCreateInfoEXT;
@@ -59461,6 +71462,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineColorBlendAdvancedStateCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const &
+                            pipelineColorBlendAdvancedStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::BlendOverlapEXT, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineColorWriteCreateInfoEXT
   {
     using NativeType = VkPipelineColorWriteCreateInfoEXT;
@@ -59580,6 +71605,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineColorWriteCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorWriteCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorWriteCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineColorWriteCreateInfoEXT.attachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::Bool32 *, seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineCompilerControlCreateInfoAMD
   {
     using NativeType = VkPipelineCompilerControlCreateInfoAMD;
@@ -59671,6 +71717,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCompilerControlCreateInfoAMD;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const &
+                            pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCompilerControlCreateInfoAMD.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCompilerControlCreateInfoAMD.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD,
+                             seed,
+                             pipelineCompilerControlCreateInfoAMD.compilerControlFlags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineCoverageModulationStateCreateInfoNV
   {
     using NativeType = VkPipelineCoverageModulationStateCreateInfoNV;
@@ -59836,6 +71902,35 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCoverageModulationStateCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const &
+                            pipelineCoverageModulationStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageModulationStateCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageModulationStateCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV,
+                             seed,
+                             pipelineCoverageModulationStateCreateInfoNV.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV,
+                             seed,
+                             pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const float *, seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineCoverageReductionStateCreateInfoNV
   {
     using NativeType = VkPipelineCoverageReductionStateCreateInfoNV;
@@ -59944,6 +72039,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCoverageReductionStateCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const &
+                            pipelineCoverageReductionStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageReductionStateCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageReductionStateCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV,
+                             seed,
+                             pipelineCoverageReductionStateCreateInfoNV.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV,
+                             seed,
+                             pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineCoverageToColorStateCreateInfoNV
   {
     using NativeType = VkPipelineCoverageToColorStateCreateInfoNV;
@@ -60061,6 +72180,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCoverageToColorStateCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const &
+                            pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageToColorStateCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageToColorStateCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV,
+                             seed,
+                             pipelineCoverageToColorStateCreateInfoNV.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineCreationFeedbackEXT
   {
     using NativeType = VkPipelineCreationFeedbackEXT;
@@ -60126,6 +72269,24 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT>::value,
     "PipelineCreationFeedbackEXT is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT const & pipelineCreationFeedbackEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT, seed, pipelineCreationFeedbackEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pipelineCreationFeedbackEXT.duration );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineCreationFeedbackCreateInfoEXT
   {
     using NativeType = VkPipelineCreationFeedbackCreateInfoEXT;
@@ -60263,6 +72424,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCreationFeedbackCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfoEXT const &
+                            pipelineCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCreationFeedbackCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCreationFeedbackCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT *,
+                             seed,
+                             pipelineCreationFeedbackCreateInfoEXT.pPipelineCreationFeedback );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCreationFeedbackCreateInfoEXT.pipelineStageCreationFeedbackCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT *,
+                             seed,
+                             pipelineCreationFeedbackCreateInfoEXT.pPipelineStageCreationFeedbacks );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineDiscardRectangleStateCreateInfoEXT
   {
     using NativeType = VkPipelineDiscardRectangleStateCreateInfoEXT;
@@ -60415,6 +72600,33 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineDiscardRectangleStateCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const &
+                            pipelineDiscardRectangleStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDiscardRectangleStateCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT,
+                             seed,
+                             pipelineDiscardRectangleStateCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT,
+                             seed,
+                             pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::Rect2D *, seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineExecutableInfoKHR
   {
     using NativeType = VkPipelineExecutableInfoKHR;
@@ -60512,6 +72724,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineExecutableInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutableInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineExecutableInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, pipelineExecutableInfoKHR.pipeline );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineExecutableInfoKHR.executableIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineExecutableInternalRepresentationKHR
   {
     using NativeType = VkPipelineExecutableInternalRepresentationKHR;
@@ -60619,6 +72850,35 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineExecutableInternalRepresentationKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const &
+                            pipelineExecutableInternalRepresentationKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutableInternalRepresentationKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutableInternalRepresentationKHR.pNext );
+    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutableInternalRepresentationKHR.name[i] );
+    }
+    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutableInternalRepresentationKHR.description[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineExecutableInternalRepresentationKHR.isText );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, pipelineExecutableInternalRepresentationKHR.dataSize );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutableInternalRepresentationKHR.pData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineExecutablePropertiesKHR
   {
     using NativeType = VkPipelineExecutablePropertiesKHR;
@@ -60703,6 +72963,34 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineExecutablePropertiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutablePropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutablePropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, pipelineExecutablePropertiesKHR.stages );
+    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutablePropertiesKHR.name[i] );
+    }
+    for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutablePropertiesKHR.description[i] );
+    }
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineExecutablePropertiesKHR.subgroupSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   union PipelineExecutableStatisticValueKHR
   {
     using NativeType = VkPipelineExecutableStatisticValueKHR;
@@ -60961,6 +73249,35 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineFragmentShadingRateEnumStateCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const &
+                            pipelineFragmentShadingRateEnumStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateTypeNV,
+                             seed,
+                             pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::FragmentShadingRateNV, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate );
+    for ( size_t i = 0; i < 2; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR,
+                               seed,
+                               pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineFragmentShadingRateStateCreateInfoKHR
   {
     using NativeType = VkPipelineFragmentShadingRateStateCreateInfoKHR;
@@ -61069,6 +73386,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineFragmentShadingRateStateCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const &
+                            pipelineFragmentShadingRateStateCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Extent2D, seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize );
+    for ( size_t i = 0; i < 2; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR,
+                               seed,
+                               pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineInfoKHR
   {
     using NativeType = VkPipelineInfoKHR;
@@ -61153,6 +73496,23 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, pipelineInfoKHR.pipeline );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PushConstantRange
   {
     using NativeType = VkPushConstantRange;
@@ -61238,6 +73598,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PushConstantRange>::value,
                             "PushConstantRange is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PushConstantRange>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, pushConstantRange.stageFlags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pushConstantRange.offset );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pushConstantRange.size );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineLayoutCreateInfo
   {
     using NativeType = VkPipelineLayoutCreateInfo;
@@ -61403,6 +73780,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineLayoutCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineLayoutCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineLayoutCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags, seed, pipelineLayoutCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLayoutCreateInfo.setLayoutCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DescriptorSetLayout *, seed, pipelineLayoutCreateInfo.pSetLayouts );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLayoutCreateInfo.pushConstantRangeCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::PushConstantRange *, seed, pipelineLayoutCreateInfo.pPushConstantRanges );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineLibraryCreateInfoKHR
   {
     using NativeType = VkPipelineLibraryCreateInfoKHR;
@@ -61519,6 +73920,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineLibraryCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineLibraryCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineLibraryCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLibraryCreateInfoKHR.libraryCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Pipeline *, seed, pipelineLibraryCreateInfoKHR.pLibraries );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineRasterizationConservativeStateCreateInfoEXT
   {
     using NativeType = VkPipelineRasterizationConservativeStateCreateInfoEXT;
@@ -61639,6 +74059,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationConservativeStateCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const &
+                            pipelineRasterizationConservativeStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT,
+                             seed,
+                             pipelineRasterizationConservativeStateCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT,
+                             seed,
+                             pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode );
+    VULKAN_HPP_HASH_COMBINE(
+      float, seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineRasterizationDepthClipStateCreateInfoEXT
   {
     using NativeType = VkPipelineRasterizationDepthClipStateCreateInfoEXT;
@@ -61745,6 +74191,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationDepthClipStateCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const &
+                            pipelineRasterizationDepthClipStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT,
+                             seed,
+                             pipelineRasterizationDepthClipStateCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineRasterizationLineStateCreateInfoEXT
   {
     using NativeType = VkPipelineRasterizationLineStateCreateInfoEXT;
@@ -61875,6 +74344,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationLineStateCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const &
+                            pipelineRasterizationLineStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationLineStateCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationLineStateCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT,
+                             seed,
+                             pipelineRasterizationLineStateCreateInfoEXT.lineRasterizationMode );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationLineStateCreateInfoEXT.stippledLineEnable );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRasterizationLineStateCreateInfoEXT.lineStippleFactor );
+    VULKAN_HPP_HASH_COMBINE( uint16_t, seed, pipelineRasterizationLineStateCreateInfoEXT.lineStipplePattern );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineRasterizationProvokingVertexStateCreateInfoEXT
   {
     using NativeType = VkPipelineRasterizationProvokingVertexStateCreateInfoEXT;
@@ -61974,6 +74468,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationProvokingVertexStateCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const &
+                            pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT,
+                             seed,
+                             pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineRasterizationStateRasterizationOrderAMD
   {
     using NativeType = VkPipelineRasterizationStateRasterizationOrderAMD;
@@ -62071,6 +74586,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationStateRasterizationOrderAMD;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const &
+                            pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateRasterizationOrderAMD.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateRasterizationOrderAMD.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RasterizationOrderAMD,
+                             seed,
+                             pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineRasterizationStateStreamCreateInfoEXT
   {
     using NativeType = VkPipelineRasterizationStateStreamCreateInfoEXT;
@@ -62177,6 +74713,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRasterizationStateStreamCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const &
+                            pipelineRasterizationStateStreamCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateStreamCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT,
+                             seed,
+                             pipelineRasterizationStateStreamCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineRenderingCreateInfoKHR
   {
     using NativeType = VkPipelineRenderingCreateInfoKHR;
@@ -62335,6 +74893,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRenderingCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfoKHR const & pipelineRenderingCreateInfoKHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRenderingCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRenderingCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRenderingCreateInfoKHR.viewMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRenderingCreateInfoKHR.colorAttachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::Format *, seed, pipelineRenderingCreateInfoKHR.pColorAttachmentFormats );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, pipelineRenderingCreateInfoKHR.depthAttachmentFormat );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Format, seed, pipelineRenderingCreateInfoKHR.stencilAttachmentFormat );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineRepresentativeFragmentTestStateCreateInfoNV
   {
     using NativeType = VkPipelineRepresentativeFragmentTestStateCreateInfoNV;
@@ -62432,6 +75014,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineRepresentativeFragmentTestStateCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const &
+                            pipelineRepresentativeFragmentTestStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
+                             seed,
+                             pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineSampleLocationsStateCreateInfoEXT
   {
     using NativeType = VkPipelineSampleLocationsStateCreateInfoEXT;
@@ -62539,6 +75142,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineSampleLocationsStateCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const &
+                            pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineSampleLocationsStateCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineSampleLocationsStateCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT,
+                             seed,
+                             pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
   {
     using NativeType = VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
@@ -62619,6 +75245,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const &
+                            pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.requiredSubgroupSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineTessellationDomainOriginStateCreateInfo
   {
     using NativeType = VkPipelineTessellationDomainOriginStateCreateInfo;
@@ -62716,6 +75362,27 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const &
+                            pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineTessellationDomainOriginStateCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineTessellationDomainOriginStateCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin,
+                             seed,
+                             pipelineTessellationDomainOriginStateCreateInfo.domainOrigin );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct VertexInputBindingDivisorDescriptionEXT
   {
     using NativeType = VkVertexInputBindingDivisorDescriptionEXT;
@@ -62800,6 +75467,23 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT>::value,
     "VertexInputBindingDivisorDescriptionEXT is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT const &
+                            vertexInputBindingDivisorDescriptionEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDivisorDescriptionEXT.binding );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDivisorDescriptionEXT.divisor );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineVertexInputDivisorStateCreateInfoEXT
   {
     using NativeType = VkPipelineVertexInputDivisorStateCreateInfoEXT;
@@ -62930,6 +75614,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineVertexInputDivisorStateCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT const &
+                            pipelineVertexInputDivisorStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineVertexInputDivisorStateCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineVertexInputDivisorStateCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputDivisorStateCreateInfoEXT.vertexBindingDivisorCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT *,
+                             seed,
+                             pipelineVertexInputDivisorStateCreateInfoEXT.pVertexBindingDivisors );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
   {
     using NativeType = VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;
@@ -63072,6 +75778,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportCoarseSampleOrderStateCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const &
+                            pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV,
+                             seed,
+                             pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV *,
+                             seed,
+                             pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineViewportDepthClipControlCreateInfoEXT
   {
     using NativeType = VkPipelineViewportDepthClipControlCreateInfoEXT;
@@ -63166,6 +75898,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportDepthClipControlCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const &
+                            pipelineViewportDepthClipControlCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportDepthClipControlCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineViewportExclusiveScissorStateCreateInfoNV
   {
     using NativeType = VkPipelineViewportExclusiveScissorStateCreateInfoNV;
@@ -63292,6 +76044,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportExclusiveScissorStateCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const &
+                            pipelineViewportExclusiveScissorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Rect2D *,
+                             seed,
+                             pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ShadingRatePaletteNV
   {
     using NativeType = VkShadingRatePaletteNV;
@@ -63391,6 +76165,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV>::value,
                             "ShadingRatePaletteNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shadingRatePaletteNV.shadingRatePaletteEntryCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV *, seed, shadingRatePaletteNV.pShadingRatePaletteEntries );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineViewportShadingRateImageStateCreateInfoNV
   {
     using NativeType = VkPipelineViewportShadingRateImageStateCreateInfoNV;
@@ -63531,6 +76323,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportShadingRateImageStateCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const &
+                            pipelineViewportShadingRateImageStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV *,
+                             seed,
+                             pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ViewportSwizzleNV
   {
     using NativeType = VkViewportSwizzleNV;
@@ -63633,6 +76449,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV>::value,
                             "ViewportSwizzleNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.x );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.y );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.z );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.w );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineViewportSwizzleStateCreateInfoNV
   {
     using NativeType = VkPipelineViewportSwizzleStateCreateInfoNV;
@@ -63771,6 +76605,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportSwizzleStateCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const &
+                            pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportSwizzleStateCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportSwizzleStateCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV,
+                             seed,
+                             pipelineViewportSwizzleStateCreateInfoNV.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV *,
+                             seed,
+                             pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ViewportWScalingNV
   {
     using NativeType = VkViewportWScalingNV;
@@ -63845,6 +76704,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ViewportWScalingNV>::value,
                             "ViewportWScalingNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ViewportWScalingNV>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( float, seed, viewportWScalingNV.xcoeff );
+    VULKAN_HPP_HASH_COMBINE( float, seed, viewportWScalingNV.ycoeff );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PipelineViewportWScalingStateCreateInfoNV
   {
     using NativeType = VkPipelineViewportWScalingStateCreateInfoNV;
@@ -63984,6 +76860,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineViewportWScalingStateCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const &
+                            pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportWScalingStateCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportWScalingStateCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ViewportWScalingNV *,
+                             seed,
+                             pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_GGP )
   struct PresentFrameTokenGGP
   {
@@ -64068,6 +76968,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = PresentFrameTokenGGP;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentFrameTokenGGP.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, presentFrameTokenGGP.pNext );
+    VULKAN_HPP_HASH_COMBINE( GgpFrameToken, seed, presentFrameTokenGGP.frameToken );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_GGP*/
 
   struct PresentIdKHR
@@ -64179,6 +77098,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PresentIdKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PresentIdKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentIdKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, presentIdKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentIdKHR.swapchainCount );
+    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, presentIdKHR.pPresentIds );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PresentInfoKHR
   {
     using NativeType = VkPresentInfoKHR;
@@ -64393,6 +77330,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PresentInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, presentInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentInfoKHR.waitSemaphoreCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, presentInfoKHR.pWaitSemaphores );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentInfoKHR.swapchainCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SwapchainKHR *, seed, presentInfoKHR.pSwapchains );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, presentInfoKHR.pImageIndices );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Result *, seed, presentInfoKHR.pResults );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RectLayerKHR
   {
     using NativeType = VkRectLayerKHR;
@@ -64483,6 +77442,23 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RectLayerKHR>::value,
                             "RectLayerKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RectLayerKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, rectLayerKHR.offset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, rectLayerKHR.extent );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rectLayerKHR.layer );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PresentRegionKHR
   {
     using NativeType = VkPresentRegionKHR;
@@ -64578,6 +77554,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PresentRegionKHR>::value,
                             "PresentRegionKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PresentRegionKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentRegionKHR.rectangleCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::RectLayerKHR *, seed, presentRegionKHR.pRectangles );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PresentRegionsKHR
   {
     using NativeType = VkPresentRegionsKHR;
@@ -64691,6 +77683,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PresentRegionsKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PresentRegionsKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentRegionsKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, presentRegionsKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentRegionsKHR.swapchainCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PresentRegionKHR *, seed, presentRegionsKHR.pRegions );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PresentTimeGOOGLE
   {
     using NativeType = VkPresentTimeGOOGLE;
@@ -64767,6 +77777,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE>::value,
                             "PresentTimeGOOGLE is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentTimeGOOGLE.presentID );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, presentTimeGOOGLE.desiredPresentTime );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PresentTimesInfoGOOGLE
   {
     using NativeType = VkPresentTimesInfoGOOGLE;
@@ -64881,6 +77907,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PresentTimesInfoGOOGLE;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentTimesInfoGOOGLE.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, presentTimesInfoGOOGLE.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentTimesInfoGOOGLE.swapchainCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE *, seed, presentTimesInfoGOOGLE.pTimes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct PrivateDataSlotCreateInfoEXT
   {
     using NativeType = VkPrivateDataSlotCreateInfoEXT;
@@ -64968,6 +78013,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PrivateDataSlotCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & privateDataSlotCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, privateDataSlotCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, privateDataSlotCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagsEXT, seed, privateDataSlotCreateInfoEXT.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ProtectedSubmitInfo
   {
     using NativeType = VkProtectedSubmitInfo;
@@ -65052,6 +78116,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ProtectedSubmitInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, protectedSubmitInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, protectedSubmitInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, protectedSubmitInfo.protectedSubmit );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct QueryPoolCreateInfo
   {
     using NativeType = VkQueryPoolCreateInfo;
@@ -65168,6 +78250,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = QueryPoolCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags, seed, queryPoolCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryType, seed, queryPoolCreateInfo.queryType );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolCreateInfo.queryCount );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags, seed, queryPoolCreateInfo.pipelineStatistics );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct QueryPoolPerformanceCreateInfoKHR
   {
     using NativeType = VkQueryPoolPerformanceCreateInfoKHR;
@@ -65298,6 +78402,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = QueryPoolPerformanceCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const &
+                            queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolPerformanceCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolPerformanceCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct QueryPoolPerformanceQueryCreateInfoINTEL
   {
     using NativeType = VkQueryPoolPerformanceQueryCreateInfoINTEL;
@@ -65397,6 +78521,27 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const &
+                            queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolPerformanceQueryCreateInfoINTEL.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL,
+                             seed,
+                             queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct QueueFamilyCheckpointProperties2NV
   {
     using NativeType = VkQueueFamilyCheckpointProperties2NV;
@@ -65474,6 +78619,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = QueueFamilyCheckpointProperties2NV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const &
+                            queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyCheckpointProperties2NV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyCheckpointProperties2NV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR,
+                             seed,
+                             queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct QueueFamilyCheckpointPropertiesNV
   {
     using NativeType = VkQueueFamilyCheckpointPropertiesNV;
@@ -65550,6 +78715,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = QueueFamilyCheckpointPropertiesNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const &
+                            queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyCheckpointPropertiesNV.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyCheckpointPropertiesNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct QueueFamilyGlobalPriorityPropertiesEXT
   {
     using NativeType = VkQueueFamilyGlobalPriorityPropertiesEXT;
@@ -65672,6 +78856,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = QueueFamilyGlobalPriorityPropertiesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT const &
+                            queueFamilyGlobalPriorityPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyGlobalPriorityPropertiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyGlobalPriorityPropertiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyGlobalPriorityPropertiesEXT.priorityCount );
+    for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_EXT; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE(
+        VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT, seed, queueFamilyGlobalPriorityPropertiesEXT.priorities[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct QueueFamilyProperties
   {
     using NativeType = VkQueueFamilyProperties;
@@ -65742,6 +78949,25 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value,
                             "QueueFamilyProperties is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueueFlags, seed, queueFamilyProperties.queueFlags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyProperties.queueCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyProperties.timestampValidBits );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, queueFamilyProperties.minImageTransferGranularity );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct QueueFamilyProperties2
   {
     using NativeType = VkQueueFamilyProperties2;
@@ -65814,6 +79040,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using QueueFamilyProperties2KHR = QueueFamilyProperties2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyProperties2.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyProperties2.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::QueueFamilyProperties, seed, queueFamilyProperties2.queueFamilyProperties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RayTracingShaderGroupCreateInfoKHR
   {
     using NativeType = VkRayTracingShaderGroupCreateInfoKHR;
@@ -65960,6 +79205,30 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RayTracingShaderGroupCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const &
+                            rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingShaderGroupCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR, seed, rayTracingShaderGroupCreateInfoKHR.type );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.generalShader );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RayTracingPipelineInterfaceCreateInfoKHR
   {
     using NativeType = VkRayTracingPipelineInterfaceCreateInfoKHR;
@@ -66067,6 +79336,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RayTracingPipelineInterfaceCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const &
+                            rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineInterfaceCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RayTracingPipelineCreateInfoKHR
   {
     using NativeType = VkRayTracingPipelineCreateInfoKHR;
@@ -66320,6 +79609,43 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RayTracingPipelineCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, rayTracingPipelineCreateInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.stageCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, rayTracingPipelineCreateInfoKHR.pStages );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.groupCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR *, seed, rayTracingPipelineCreateInfoKHR.pGroups );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR *, seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR *,
+                             seed,
+                             rayTracingPipelineCreateInfoKHR.pLibraryInterface );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo *,
+                             seed,
+                             rayTracingPipelineCreateInfoKHR.pDynamicState );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, rayTracingPipelineCreateInfoKHR.layout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RayTracingShaderGroupCreateInfoNV
   {
     using NativeType = VkRayTracingShaderGroupCreateInfoNV;
@@ -66454,6 +79780,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RayTracingShaderGroupCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const &
+                            rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingShaderGroupCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR, seed, rayTracingShaderGroupCreateInfoNV.type );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.generalShader );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.closestHitShader );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.anyHitShader );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.intersectionShader );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RayTracingPipelineCreateInfoNV
   {
     using NativeType = VkRayTracingPipelineCreateInfoNV;
@@ -66669,6 +80018,34 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RayTracingPipelineCreateInfoNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineCreateInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineCreateInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, rayTracingPipelineCreateInfoNV.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.stageCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, rayTracingPipelineCreateInfoNV.pStages );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.groupCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV *, seed, rayTracingPipelineCreateInfoNV.pGroups );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, rayTracingPipelineCreateInfoNV.layout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, rayTracingPipelineCreateInfoNV.basePipelineHandle );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, rayTracingPipelineCreateInfoNV.basePipelineIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RefreshCycleDurationGOOGLE
   {
     using NativeType = VkRefreshCycleDurationGOOGLE;
@@ -66729,6 +80106,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::value,
                             "RefreshCycleDurationGOOGLE is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, refreshCycleDurationGOOGLE.refreshDuration );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderPassAttachmentBeginInfo
   {
     using NativeType = VkRenderPassAttachmentBeginInfo;
@@ -66848,6 +80241,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassAttachmentBeginInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassAttachmentBeginInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassAttachmentBeginInfo.attachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::ImageView *, seed, renderPassAttachmentBeginInfo.pAttachments );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderPassBeginInfo
   {
     using NativeType = VkRenderPassBeginInfo;
@@ -66999,6 +80412,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderPassBeginInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassBeginInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassBeginInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, renderPassBeginInfo.renderPass );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Framebuffer, seed, renderPassBeginInfo.framebuffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, renderPassBeginInfo.renderArea );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassBeginInfo.clearValueCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ClearValue *, seed, renderPassBeginInfo.pClearValues );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubpassDescription
   {
     using NativeType = VkSubpassDescription;
@@ -67242,6 +80677,35 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassDescription>::value,
                             "SubpassDescription is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDescription>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags, seed, subpassDescription.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, subpassDescription.pipelineBindPoint );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.inputAttachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pInputAttachments );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.colorAttachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pColorAttachments );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pResolveAttachments );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pDepthStencilAttachment );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.preserveAttachmentCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, subpassDescription.pPreserveAttachments );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubpassDependency
   {
     using NativeType = VkSubpassDependency;
@@ -67371,6 +80835,27 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassDependency>::value,
                             "SubpassDependency is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDependency>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency.srcSubpass );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency.dstSubpass );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency.srcStageMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency.dstStageMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency.srcAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency.dstAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, subpassDependency.dependencyFlags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderPassCreateInfo
   {
     using NativeType = VkRenderPassCreateInfo;
@@ -67568,6 +81053,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderPassCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags, seed, renderPassCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.attachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::AttachmentDescription *, seed, renderPassCreateInfo.pAttachments );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.subpassCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubpassDescription *, seed, renderPassCreateInfo.pSubpasses );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.dependencyCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SubpassDependency *, seed, renderPassCreateInfo.pDependencies );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubpassDescription2
   {
     using NativeType = VkSubpassDescription2;
@@ -67841,6 +81352,38 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SubpassDescription2KHR = SubpassDescription2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDescription2>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDescription2.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDescription2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags, seed, subpassDescription2.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, subpassDescription2.pipelineBindPoint );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.viewMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.inputAttachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pInputAttachments );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.colorAttachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pColorAttachments );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pResolveAttachments );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pDepthStencilAttachment );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.preserveAttachmentCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, subpassDescription2.pPreserveAttachments );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubpassDependency2
   {
     using NativeType = VkSubpassDependency2;
@@ -67997,6 +81540,31 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SubpassDependency2KHR = SubpassDependency2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDependency2>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDependency2.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDependency2.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency2.srcSubpass );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency2.dstSubpass );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency2.srcStageMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency2.dstStageMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency2.srcAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency2.dstAccessMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, subpassDependency2.dependencyFlags );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, subpassDependency2.viewOffset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderPassCreateInfo2
   {
     using NativeType = VkRenderPassCreateInfo2;
@@ -68229,6 +81797,35 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassCreateInfo2.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassCreateInfo2.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags, seed, renderPassCreateInfo2.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.attachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::AttachmentDescription2 *, seed, renderPassCreateInfo2.pAttachments );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.subpassCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SubpassDescription2 *, seed, renderPassCreateInfo2.pSubpasses );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.dependencyCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SubpassDependency2 *, seed, renderPassCreateInfo2.pDependencies );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.correlatedViewMaskCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassCreateInfo2.pCorrelatedViewMasks );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderPassFragmentDensityMapCreateInfoEXT
   {
     using NativeType = VkRenderPassFragmentDensityMapCreateInfoEXT;
@@ -68325,6 +81922,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderPassFragmentDensityMapCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const &
+                            renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassFragmentDensityMapCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassFragmentDensityMapCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentReference,
+                             seed,
+                             renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderPassInputAttachmentAspectCreateInfo
   {
     using NativeType = VkRenderPassInputAttachmentAspectCreateInfo;
@@ -68452,6 +82070,28 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const &
+                            renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassInputAttachmentAspectCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassInputAttachmentAspectCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference *,
+                             seed,
+                             renderPassInputAttachmentAspectCreateInfo.pAspectReferences );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderPassMultiviewCreateInfo
   {
     using NativeType = VkRenderPassMultiviewCreateInfo;
@@ -68638,6 +82278,29 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassMultiviewCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassMultiviewCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.subpassCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassMultiviewCreateInfo.pViewMasks );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.dependencyCount );
+    VULKAN_HPP_HASH_COMBINE( const int32_t *, seed, renderPassMultiviewCreateInfo.pViewOffsets );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.correlationMaskCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassMultiviewCreateInfo.pCorrelationMasks );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubpassSampleLocationsEXT
   {
     using NativeType = VkSubpassSampleLocationsEXT;
@@ -68717,6 +82380,24 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>::value,
                             "SubpassSampleLocationsEXT is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassSampleLocationsEXT.subpassIndex );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT, seed, subpassSampleLocationsEXT.sampleLocationsInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderPassSampleLocationsBeginInfoEXT
   {
     using NativeType = VkRenderPassSampleLocationsBeginInfoEXT;
@@ -68879,6 +82560,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderPassSampleLocationsBeginInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const &
+                            renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassSampleLocationsBeginInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassSampleLocationsBeginInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT *,
+                             seed,
+                             renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT *,
+                             seed,
+                             renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderPassTransformBeginInfoQCOM
   {
     using NativeType = VkRenderPassTransformBeginInfoQCOM;
@@ -68969,6 +82676,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderPassTransformBeginInfoQCOM;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassTransformBeginInfoQCOM.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, renderPassTransformBeginInfoQCOM.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, renderPassTransformBeginInfoQCOM.transform );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderingAttachmentInfoKHR
   {
     using NativeType = VkRenderingAttachmentInfoKHR;
@@ -69219,6 +82946,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderingFragmentDensityMapAttachmentInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const &
+                            renderingFragmentDensityMapAttachmentInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, renderingFragmentDensityMapAttachmentInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageView, seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageLayout, seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderingFragmentShadingRateAttachmentInfoKHR
   {
     using NativeType = VkRenderingFragmentShadingRateAttachmentInfoKHR;
@@ -69336,6 +83085,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderingFragmentShadingRateAttachmentInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const &
+                            renderingFragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, renderingFragmentShadingRateAttachmentInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageView, seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ImageLayout, seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D,
+                             seed,
+                             renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct RenderingInfoKHR
   {
     using NativeType = VkRenderingInfoKHR;
@@ -69524,6 +83298,33 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = RenderingInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::RenderingInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfoKHR const & renderingInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderingInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderingFlagsKHR, seed, renderingInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, renderingInfoKHR.renderArea );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.layerCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.viewMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.colorAttachmentCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pColorAttachments );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pDepthAttachment );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pStencilAttachment );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ResolveImageInfo2KHR
   {
     using NativeType = VkResolveImageInfo2KHR;
@@ -69688,6 +83489,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ResolveImageInfo2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR const & resolveImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, resolveImageInfo2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, resolveImageInfo2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, resolveImageInfo2KHR.srcImage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, resolveImageInfo2KHR.srcImageLayout );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, resolveImageInfo2KHR.dstImage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, resolveImageInfo2KHR.dstImageLayout );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, resolveImageInfo2KHR.regionCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageResolve2KHR *, seed, resolveImageInfo2KHR.pRegions );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SamplerBorderColorComponentMappingCreateInfoEXT
   {
     using NativeType = VkSamplerBorderColorComponentMappingCreateInfoEXT;
@@ -69794,6 +83618,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SamplerBorderColorComponentMappingCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const &
+                            samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, samplerBorderColorComponentMappingCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ComponentMapping, seed, samplerBorderColorComponentMappingCreateInfoEXT.components );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SamplerCreateInfo
   {
     using NativeType = VkSamplerCreateInfo;
@@ -70032,6 +83877,38 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SamplerCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerCreateFlags, seed, samplerCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerCreateInfo.magFilter );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerCreateInfo.minFilter );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerMipmapMode, seed, samplerCreateInfo.mipmapMode );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeU );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeV );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeW );
+    VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.mipLodBias );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.anisotropyEnable );
+    VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.maxAnisotropy );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.compareEnable );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CompareOp, seed, samplerCreateInfo.compareOp );
+    VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.minLod );
+    VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.maxLod );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BorderColor, seed, samplerCreateInfo.borderColor );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.unnormalizedCoordinates );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SamplerCustomBorderColorCreateInfoEXT
   {
     using NativeType = VkSamplerCustomBorderColorCreateInfoEXT;
@@ -70212,6 +84089,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerReductionModeCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerReductionModeCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SamplerReductionMode, seed, samplerReductionModeCreateInfo.reductionMode );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SamplerYcbcrConversionCreateInfo
   {
     using NativeType = VkSamplerYcbcrConversionCreateInfo;
@@ -70377,6 +84273,38 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerYcbcrConversionCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, samplerYcbcrConversionCreateInfo.format );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion, seed, samplerYcbcrConversionCreateInfo.ycbcrModel );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, samplerYcbcrConversionCreateInfo.ycbcrRange );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ComponentMapping, seed, samplerYcbcrConversionCreateInfo.components );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, samplerYcbcrConversionCreateInfo.xChromaOffset );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ChromaLocation, seed, samplerYcbcrConversionCreateInfo.yChromaOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerYcbcrConversionCreateInfo.chromaFilter );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SamplerYcbcrConversionImageFormatProperties
   {
     using NativeType = VkSamplerYcbcrConversionImageFormatProperties;
@@ -70458,6 +84386,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const &
+                            samplerYcbcrConversionImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionImageFormatProperties.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, samplerYcbcrConversionImageFormatProperties.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      uint32_t, seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SamplerYcbcrConversionInfo
   {
     using NativeType = VkSamplerYcbcrConversionInfo;
@@ -70546,6 +84494,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerYcbcrConversionInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, seed, samplerYcbcrConversionInfo.conversion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
   struct ScreenSurfaceCreateInfoQNX
   {
@@ -70653,6 +84620,28 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ScreenSurfaceCreateInfoQNX;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, screenSurfaceCreateInfoQNX.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, screenSurfaceCreateInfoQNX.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX, seed, screenSurfaceCreateInfoQNX.flags );
+    VULKAN_HPP_HASH_COMBINE( struct _screen_context *, seed, screenSurfaceCreateInfoQNX.context );
+    VULKAN_HPP_HASH_COMBINE( struct _screen_window *, seed, screenSurfaceCreateInfoQNX.window );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
   struct SemaphoreCreateInfo
@@ -70740,6 +84729,24 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SemaphoreCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags, seed, semaphoreCreateInfo.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SemaphoreGetFdInfoKHR
   {
     using NativeType = VkSemaphoreGetFdInfoKHR;
@@ -70838,6 +84845,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SemaphoreGetFdInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetFdInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetFdInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetFdInfoKHR.semaphore );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetFdInfoKHR.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct SemaphoreGetWin32HandleInfoKHR
   {
@@ -70940,6 +84967,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SemaphoreGetWin32HandleInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetWin32HandleInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetWin32HandleInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetWin32HandleInfoKHR.semaphore );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetWin32HandleInfoKHR.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
@@ -71046,6 +85094,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SemaphoreGetZirconHandleInfoFUCHSIA;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const &
+                            semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetZirconHandleInfoFUCHSIA.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct SemaphoreSignalInfo
@@ -71143,6 +85212,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreSignalInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreSignalInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreSignalInfo.semaphore );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreSignalInfo.value );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SemaphoreSubmitInfoKHR
   {
     using NativeType = VkSemaphoreSubmitInfoKHR;
@@ -71257,6 +85345,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SemaphoreSubmitInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR const & semaphoreSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreSubmitInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreSubmitInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreSubmitInfoKHR.semaphore );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreSubmitInfoKHR.value );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, semaphoreSubmitInfoKHR.stageMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, semaphoreSubmitInfoKHR.deviceIndex );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SemaphoreTypeCreateInfo
   {
     using NativeType = VkSemaphoreTypeCreateInfo;
@@ -71354,6 +85463,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreTypeCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreTypeCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreType, seed, semaphoreTypeCreateInfo.semaphoreType );
+    VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreTypeCreateInfo.initialValue );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SemaphoreWaitInfo
   {
     using NativeType = VkSemaphoreWaitInfo;
@@ -71512,6 +85640,26 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreWaitInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreWaitInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags, seed, semaphoreWaitInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, semaphoreWaitInfo.semaphoreCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, semaphoreWaitInfo.pSemaphores );
+    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, semaphoreWaitInfo.pValues );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SetStateFlagsIndirectCommandNV
   {
     using NativeType = VkSetStateFlagsIndirectCommandNV;
@@ -71580,6 +85728,22 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>::value,
     "SetStateFlagsIndirectCommandNV is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, setStateFlagsIndirectCommandNV.data );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ShaderModuleCreateInfo
   {
     using NativeType = VkShaderModuleCreateInfo;
@@ -71701,6 +85865,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ShaderModuleCreateInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, shaderModuleCreateInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, shaderModuleCreateInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags, seed, shaderModuleCreateInfo.flags );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderModuleCreateInfo.codeSize );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, shaderModuleCreateInfo.pCode );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ShaderModuleValidationCacheCreateInfoEXT
   {
     using NativeType = VkShaderModuleValidationCacheCreateInfoEXT;
@@ -71796,6 +85980,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ShaderModuleValidationCacheCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const &
+                            shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, shaderModuleValidationCacheCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, shaderModuleValidationCacheCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ValidationCacheEXT, seed, shaderModuleValidationCacheCreateInfoEXT.validationCache );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ShaderResourceUsageAMD
   {
     using NativeType = VkShaderResourceUsageAMD;
@@ -71870,6 +86074,26 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD>::value,
                             "ShaderResourceUsageAMD is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.numUsedVgprs );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.numUsedSgprs );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderResourceUsageAMD.ldsUsageSizeInBytes );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderResourceUsageAMD.scratchMemUsageInBytes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ShaderStatisticsInfoAMD
   {
     using NativeType = VkShaderStatisticsInfoAMD;
@@ -71952,6 +86176,32 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD>::value,
                             "ShaderStatisticsInfoAMD is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, shaderStatisticsInfoAMD.shaderStageMask );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD, seed, shaderStatisticsInfoAMD.resourceUsage );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numPhysicalVgprs );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numPhysicalSgprs );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numAvailableVgprs );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numAvailableSgprs );
+    for ( size_t i = 0; i < 3; ++i )
+    {
+      VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] );
+    }
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SharedPresentSurfaceCapabilitiesKHR
   {
     using NativeType = VkSharedPresentSurfaceCapabilitiesKHR;
@@ -72029,6 +86279,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SharedPresentSurfaceCapabilitiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const &
+                            sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sharedPresentSurfaceCapabilitiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, sharedPresentSurfaceCapabilitiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags,
+                             seed,
+                             sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SparseImageFormatProperties
   {
     using NativeType = VkSparseImageFormatProperties;
@@ -72097,6 +86367,24 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value,
     "SparseImageFormatProperties is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, sparseImageFormatProperties.aspectMask );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, sparseImageFormatProperties.imageGranularity );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseImageFormatFlags, seed, sparseImageFormatProperties.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SparseImageFormatProperties2
   {
     using NativeType = VkSparseImageFormatProperties2;
@@ -72171,6 +86459,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sparseImageFormatProperties2.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, sparseImageFormatProperties2.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, seed, sparseImageFormatProperties2.properties );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SparseImageMemoryRequirements
   {
     using NativeType = VkSparseImageMemoryRequirements;
@@ -72248,6 +86555,27 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value,
     "SparseImageMemoryRequirements is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, seed, sparseImageMemoryRequirements.formatProperties );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageMemoryRequirements.imageMipTailFirstLod );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailSize );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailStride );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SparseImageMemoryRequirements2
   {
     using NativeType = VkSparseImageMemoryRequirements2;
@@ -72323,6 +86651,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sparseImageMemoryRequirements2.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, sparseImageMemoryRequirements2.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, seed, sparseImageMemoryRequirements2.memoryRequirements );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_GGP )
   struct StreamDescriptorSurfaceCreateInfoGGP
   {
@@ -72425,6 +86772,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = StreamDescriptorSurfaceCreateInfoGGP;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const &
+                            streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, streamDescriptorSurfaceCreateInfoGGP.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, streamDescriptorSurfaceCreateInfoGGP.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP, seed, streamDescriptorSurfaceCreateInfoGGP.flags );
+    VULKAN_HPP_HASH_COMBINE( GgpStreamDescriptor, seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_GGP*/
 
   struct StridedDeviceAddressRegionKHR
@@ -72519,6 +86887,24 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR>::value,
     "StridedDeviceAddressRegionKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceAddress, seed, stridedDeviceAddressRegionKHR.deviceAddress );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, stridedDeviceAddressRegionKHR.stride );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, stridedDeviceAddressRegionKHR.size );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubmitInfo
   {
     using NativeType = VkSubmitInfo;
@@ -72737,6 +87123,29 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SubmitInfo;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubmitInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, submitInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, submitInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.waitSemaphoreCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, submitInfo.pWaitSemaphores );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineStageFlags *, seed, submitInfo.pWaitDstStageMask );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.commandBufferCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::CommandBuffer *, seed, submitInfo.pCommandBuffers );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.signalSemaphoreCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, submitInfo.pSignalSemaphores );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubmitInfo2KHR
   {
     using NativeType = VkSubmitInfo2KHR;
@@ -72939,6 +87348,32 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SubmitInfo2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubmitInfo2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2KHR const & submitInfo2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, submitInfo2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, submitInfo2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubmitFlagsKHR, seed, submitInfo2KHR.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.waitSemaphoreInfoCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR *, seed, submitInfo2KHR.pWaitSemaphoreInfos );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.commandBufferInfoCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR *, seed, submitInfo2KHR.pCommandBufferInfos );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.signalSemaphoreInfoCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR *, seed, submitInfo2KHR.pSignalSemaphoreInfos );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubpassBeginInfo
   {
     using NativeType = VkSubpassBeginInfo;
@@ -73025,6 +87460,23 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SubpassBeginInfoKHR = SubpassBeginInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubpassBeginInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassBeginInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassBeginInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassContents, seed, subpassBeginInfo.contents );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubpassDescriptionDepthStencilResolve
   {
     using NativeType = VkSubpassDescriptionDepthStencilResolve;
@@ -73140,6 +87592,30 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const &
+                            subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDescriptionDepthStencilResolve.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDescriptionDepthStencilResolve.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ResolveModeFlagBits, seed, subpassDescriptionDepthStencilResolve.depthResolveMode );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ResolveModeFlagBits, seed, subpassDescriptionDepthStencilResolve.stencilResolveMode );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentReference2 *,
+                             seed,
+                             subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubpassEndInfo
   {
     using NativeType = VkSubpassEndInfo;
@@ -73215,6 +87691,22 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using SubpassEndInfoKHR = SubpassEndInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubpassEndInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassEndInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassEndInfo.pNext );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SubpassShadingPipelineCreateInfoHUAWEI
   {
     using NativeType = VkSubpassShadingPipelineCreateInfoHUAWEI;
@@ -73296,6 +87788,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SubpassShadingPipelineCreateInfoHUAWEI;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const &
+                            subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassShadingPipelineCreateInfoHUAWEI.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, subpassShadingPipelineCreateInfoHUAWEI.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::RenderPass, seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassShadingPipelineCreateInfoHUAWEI.subpass );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SurfaceCapabilities2EXT
   {
     using NativeType = VkSurfaceCapabilities2EXT;
@@ -73406,6 +87918,38 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SurfaceCapabilities2EXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilities2EXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilities2EXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.minImageCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.maxImageCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.currentExtent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.minImageExtent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.maxImageExtent );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.maxImageArrayLayers );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, surfaceCapabilities2EXT.supportedTransforms );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, surfaceCapabilities2EXT.currentTransform );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR, seed, surfaceCapabilities2EXT.supportedCompositeAlpha );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, surfaceCapabilities2EXT.supportedUsageFlags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT, seed, surfaceCapabilities2EXT.supportedSurfaceCounters );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SurfaceCapabilitiesKHR
   {
     using NativeType = VkSurfaceCapabilitiesKHR;
@@ -73500,6 +88044,34 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::value,
                             "SurfaceCapabilitiesKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.minImageCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.maxImageCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.currentExtent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.minImageExtent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.maxImageExtent );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.maxImageArrayLayers );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, surfaceCapabilitiesKHR.supportedTransforms );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, surfaceCapabilitiesKHR.currentTransform );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR, seed, surfaceCapabilitiesKHR.supportedCompositeAlpha );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, surfaceCapabilitiesKHR.supportedUsageFlags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SurfaceCapabilities2KHR
   {
     using NativeType = VkSurfaceCapabilities2KHR;
@@ -73571,6 +88143,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SurfaceCapabilities2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilities2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilities2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR, seed, surfaceCapabilities2KHR.surfaceCapabilities );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct SurfaceCapabilitiesFullScreenExclusiveEXT
   {
@@ -73666,6 +88257,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SurfaceCapabilitiesFullScreenExclusiveEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const &
+                            surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct SurfaceFormatKHR
@@ -73731,6 +88343,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value,
                             "SurfaceFormatKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, surfaceFormatKHR.format );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ColorSpaceKHR, seed, surfaceFormatKHR.colorSpace );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SurfaceFormat2KHR
   {
     using NativeType = VkSurfaceFormat2KHR;
@@ -73801,6 +88429,23 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SurfaceFormat2KHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFormat2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceFormat2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, seed, surfaceFormat2KHR.surfaceFormat );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   struct SurfaceFullScreenExclusiveInfoEXT
   {
@@ -73893,6 +88538,26 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SurfaceFullScreenExclusiveInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const &
+                            surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFullScreenExclusiveInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceFullScreenExclusiveInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT, seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -73987,6 +88652,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = SurfaceFullScreenExclusiveWin32InfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const &
+                            surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFullScreenExclusiveWin32InfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( HMONITOR, seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct SurfaceProtectedCapabilitiesKHR
@@ -74078,6 +88762,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SurfaceProtectedCapabilitiesKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceProtectedCapabilitiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, surfaceProtectedCapabilitiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, surfaceProtectedCapabilitiesKHR.supportsProtected );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SwapchainCounterCreateInfoEXT
   {
     using NativeType = VkSwapchainCounterCreateInfoEXT;
@@ -74167,6 +88870,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SwapchainCounterCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainCounterCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainCounterCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT, seed, swapchainCounterCreateInfoEXT.surfaceCounters );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SwapchainCreateInfoKHR
   {
     using NativeType = VkSwapchainCreateInfoKHR;
@@ -74461,6 +89183,41 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SwapchainCreateInfoKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR, seed, swapchainCreateInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceKHR, seed, swapchainCreateInfoKHR.surface );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.minImageCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, swapchainCreateInfoKHR.imageFormat );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ColorSpaceKHR, seed, swapchainCreateInfoKHR.imageColorSpace );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, swapchainCreateInfoKHR.imageExtent );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.imageArrayLayers );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, swapchainCreateInfoKHR.imageUsage );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, swapchainCreateInfoKHR.imageSharingMode );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.queueFamilyIndexCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, swapchainCreateInfoKHR.pQueueFamilyIndices );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, swapchainCreateInfoKHR.preTransform );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::CompositeAlphaFlagBitsKHR, seed, swapchainCreateInfoKHR.compositeAlpha );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PresentModeKHR, seed, swapchainCreateInfoKHR.presentMode );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, swapchainCreateInfoKHR.clipped );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, swapchainCreateInfoKHR.oldSwapchain );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct SwapchainDisplayNativeHdrCreateInfoAMD
   {
     using NativeType = VkSwapchainDisplayNativeHdrCreateInfoAMD;
@@ -74553,6 +89310,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = SwapchainDisplayNativeHdrCreateInfoAMD;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const &
+                            swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainDisplayNativeHdrCreateInfoAMD.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct TextureLODGatherFormatPropertiesAMD
   {
     using NativeType = VkTextureLODGatherFormatPropertiesAMD;
@@ -74630,6 +89406,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = TextureLODGatherFormatPropertiesAMD;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const &
+                            textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, textureLODGatherFormatPropertiesAMD.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, textureLODGatherFormatPropertiesAMD.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct TimelineSemaphoreSubmitInfo
   {
     using NativeType = VkTimelineSemaphoreSubmitInfo;
@@ -74784,6 +89579,27 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, timelineSemaphoreSubmitInfo.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, timelineSemaphoreSubmitInfo.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount );
+    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount );
+    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct TraceRaysIndirectCommandKHR
   {
     using NativeType = VkTraceRaysIndirectCommandKHR;
@@ -74875,6 +89691,24 @@ namespace VULKAN_HPP_NAMESPACE
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR>::value,
     "TraceRaysIndirectCommandKHR is not nothrow_move_constructible!" );
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.width );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.height );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.depth );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ValidationCacheCreateInfoEXT
   {
     using NativeType = VkValidationCacheCreateInfoEXT;
@@ -75002,6 +89836,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ValidationCacheCreateInfoEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT>
+{
+  std::size_t operator()(
+    VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationCacheCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, validationCacheCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT, seed, validationCacheCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( size_t, seed, validationCacheCreateInfoEXT.initialDataSize );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, validationCacheCreateInfoEXT.pInitialData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ValidationFeaturesEXT
   {
     using NativeType = VkValidationFeaturesEXT;
@@ -75156,6 +90011,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ValidationFeaturesEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationFeaturesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, validationFeaturesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFeaturesEXT.enabledValidationFeatureCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT *,
+                             seed,
+                             validationFeaturesEXT.pEnabledValidationFeatures );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFeaturesEXT.disabledValidationFeatureCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT *,
+                             seed,
+                             validationFeaturesEXT.pDisabledValidationFeatures );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct ValidationFlagsEXT
   {
     using NativeType = VkValidationFlagsEXT;
@@ -75273,6 +90153,26 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = ValidationFlagsEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ValidationFlagsEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationFlagsEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, validationFlagsEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFlagsEXT.disabledValidationCheckCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::ValidationCheckEXT *, seed, validationFlagsEXT.pDisabledValidationChecks );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct VertexInputAttributeDescription2EXT
   {
     using NativeType = VkVertexInputAttributeDescription2EXT;
@@ -75392,6 +90292,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = VertexInputAttributeDescription2EXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const &
+                            vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, vertexInputAttributeDescription2EXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, vertexInputAttributeDescription2EXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.location );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.binding );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, vertexInputAttributeDescription2EXT.format );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.offset );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct VertexInputBindingDescription2EXT
   {
     using NativeType = VkVertexInputBindingDescription2EXT;
@@ -75510,6 +90431,27 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = VertexInputBindingDescription2EXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const &
+                            vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, vertexInputBindingDescription2EXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, vertexInputBindingDescription2EXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.binding );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.stride );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VertexInputRate, seed, vertexInputBindingDescription2EXT.inputRate );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.divisor );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_VI_NN )
   struct ViSurfaceCreateInfoNN
   {
@@ -75603,6 +90545,26 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = ViSurfaceCreateInfoNN;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, viSurfaceCreateInfoNN.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, viSurfaceCreateInfoNN.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN, seed, viSurfaceCreateInfoNN.flags );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, viSurfaceCreateInfoNN.window );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_VI_NN*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -75722,6 +90684,28 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoPictureResourceKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR const & videoPictureResourceKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoPictureResourceKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoPictureResourceKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, videoPictureResourceKHR.codedOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoPictureResourceKHR.codedExtent );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoPictureResourceKHR.baseArrayLayer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, videoPictureResourceKHR.imageViewBinding );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -75819,6 +90803,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoReferenceSlotKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR const & videoReferenceSlotKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoReferenceSlotKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoReferenceSlotKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoReferenceSlotKHR.slotIndex );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR *, seed, videoReferenceSlotKHR.pPictureResource );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -75988,6 +90993,33 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoBeginCodingInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoBeginCodingInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoBeginCodingInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagsKHR, seed, videoBeginCodingInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoCodingQualityPresetFlagsKHR, seed, videoBeginCodingInfoKHR.codecQualityPreset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionKHR, seed, videoBeginCodingInfoKHR.videoSession );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, seed, videoBeginCodingInfoKHR.videoSessionParameters );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoBeginCodingInfoKHR.referenceSlotCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoBeginCodingInfoKHR.pReferenceSlots );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -76104,6 +91136,28 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoBindMemoryKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR const & videoBindMemoryKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoBindMemoryKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoBindMemoryKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoBindMemoryKHR.memoryBindIndex );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, videoBindMemoryKHR.memory );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoBindMemoryKHR.memoryOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoBindMemoryKHR.memorySize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -76202,6 +91256,35 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoCapabilitiesKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoCapabilitiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, videoCapabilitiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR, seed, videoCapabilitiesKHR.capabilityFlags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.videoPictureExtentGranularity );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.minExtent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.maxExtent );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoCapabilitiesKHR.maxReferencePicturesSlotsCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoCapabilitiesKHR.maxReferencePicturesActiveCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -76291,6 +91374,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoCodingControlInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoCodingControlInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoCodingControlInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoCodingControlFlagsKHR, seed, videoCodingControlInfoKHR.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -76375,6 +91477,29 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264CapabilitiesEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT const & videoDecodeH264CapabilitiesEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264CapabilitiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, videoDecodeH264CapabilitiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264CapabilitiesEXT.maxLevel );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Offset2D, seed, videoDecodeH264CapabilitiesEXT.fieldOffsetGranularity );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoDecodeH264CapabilitiesEXT.stdExtensionVersion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -76466,6 +91591,26 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264DpbSlotInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoEXT const & videoDecodeH264DpbSlotInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264DpbSlotInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264DpbSlotInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoDecodeH264ReferenceInfo *, seed, videoDecodeH264DpbSlotInfoEXT.pStdReferenceInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -76552,6 +91697,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264MvcEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264MvcEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264MvcEXT const & videoDecodeH264MvcEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264MvcEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264MvcEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( const StdVideoDecodeH264Mvc *, seed, videoDecodeH264MvcEXT.pStdMvc );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -76682,6 +91846,28 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264PictureInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoEXT const & videoDecodeH264PictureInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264PictureInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264PictureInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoDecodeH264PictureInfo *, seed, videoDecodeH264PictureInfoEXT.pStdPictureInfo );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264PictureInfoEXT.slicesCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, videoDecodeH264PictureInfoEXT.pSlicesDataOffsets );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -76783,6 +91969,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264ProfileEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileEXT const & videoDecodeH264ProfileEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264ProfileEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264ProfileEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( StdVideoH264ProfileIdc, seed, videoDecodeH264ProfileEXT.stdProfileIdc );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT, seed, videoDecodeH264ProfileEXT.pictureLayout );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -76887,6 +92094,29 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264SessionCreateInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionCreateInfoEXT const &
+                            videoDecodeH264SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoDecodeH264CreateFlagsEXT, seed, videoDecodeH264SessionCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
+                             seed,
+                             videoDecodeH264SessionCreateInfoEXT.pStdExtensionVersion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -77048,6 +92278,31 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264SessionParametersAddInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT const &
+                            videoDecodeH264SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionParametersAddInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionParametersAddInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersAddInfoEXT.spsStdCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoH264SequenceParameterSet *, seed, videoDecodeH264SessionParametersAddInfoEXT.pSpsStd );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersAddInfoEXT.ppsStdCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoH264PictureParameterSet *, seed, videoDecodeH264SessionParametersAddInfoEXT.pPpsStd );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -77167,6 +92422,30 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH264SessionParametersCreateInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoEXT const &
+                            videoDecodeH264SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionParametersCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionParametersCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersCreateInfoEXT.maxSpsStdCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersCreateInfoEXT.maxPpsStdCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT *,
+                             seed,
+                             videoDecodeH264SessionParametersCreateInfoEXT.pParametersAddInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -77246,6 +92525,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265CapabilitiesEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT const & videoDecodeH265CapabilitiesEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265CapabilitiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, videoDecodeH265CapabilitiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265CapabilitiesEXT.maxLevel );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoDecodeH265CapabilitiesEXT.stdExtensionVersion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -77337,6 +92637,26 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265DpbSlotInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoEXT const & videoDecodeH265DpbSlotInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265DpbSlotInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265DpbSlotInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoDecodeH265ReferenceInfo *, seed, videoDecodeH265DpbSlotInfoEXT.pStdReferenceInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -77467,6 +92787,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265PictureInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoEXT const & videoDecodeH265PictureInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265PictureInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265PictureInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( StdVideoDecodeH265PictureInfo *, seed, videoDecodeH265PictureInfoEXT.pStdPictureInfo );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265PictureInfoEXT.slicesCount );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, videoDecodeH265PictureInfoEXT.pSlicesDataOffsets );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -77556,6 +92897,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265ProfileEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileEXT const & videoDecodeH265ProfileEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265ProfileEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265ProfileEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( StdVideoH265ProfileIdc, seed, videoDecodeH265ProfileEXT.stdProfileIdc );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -77660,6 +93020,29 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265SessionCreateInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionCreateInfoEXT const &
+                            videoDecodeH265SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoDecodeH265CreateFlagsEXT, seed, videoDecodeH265SessionCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
+                             seed,
+                             videoDecodeH265SessionCreateInfoEXT.pStdExtensionVersion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -77821,6 +93204,31 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265SessionParametersAddInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT const &
+                            videoDecodeH265SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionParametersAddInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionParametersAddInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersAddInfoEXT.spsStdCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoH265SequenceParameterSet *, seed, videoDecodeH265SessionParametersAddInfoEXT.pSpsStd );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersAddInfoEXT.ppsStdCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoH265PictureParameterSet *, seed, videoDecodeH265SessionParametersAddInfoEXT.pPpsStd );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -77940,6 +93348,30 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeH265SessionParametersCreateInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoEXT const &
+                            videoDecodeH265SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionParametersCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionParametersCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersCreateInfoEXT.maxSpsStdCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersCreateInfoEXT.maxPpsStdCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT *,
+                             seed,
+                             videoDecodeH265SessionParametersCreateInfoEXT.pParametersAddInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -78158,6 +93590,37 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoDecodeInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR, seed, videoDecodeInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, videoDecodeInfoKHR.codedOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoDecodeInfoKHR.codedExtent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, videoDecodeInfoKHR.srcBuffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoDecodeInfoKHR.srcBufferOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoDecodeInfoKHR.srcBufferRange );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR, seed, videoDecodeInfoKHR.dstPictureResource );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoDecodeInfoKHR.pSetupReferenceSlot );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeInfoKHR.referenceSlotCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoDecodeInfoKHR.pReferenceSlots );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -78355,6 +93818,40 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264CapabilitiesEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT const & videoEncodeH264CapabilitiesEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264CapabilitiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264CapabilitiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.inputModeFlags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.outputModeFlags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.minPictureSizeInMbs );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.maxPictureSizeInMbs );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.inputImageDataAlignment );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForP );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForB );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL1Reference );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.qualityLevelCount );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoEncodeH264CapabilitiesEXT.stdExtensionVersion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -78456,6 +93953,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264DpbSlotInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT const & videoEncodeH264DpbSlotInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264DpbSlotInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264DpbSlotInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoEncodeH264DpbSlotInfoEXT.slotIndex );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoEncodeH264PictureInfo *, seed, videoEncodeH264DpbSlotInfoEXT.pStdPictureInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -78605,6 +94123,29 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264EmitPictureParametersEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264EmitPictureParametersEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264EmitPictureParametersEXT const &
+                            videoEncodeH264EmitPictureParametersEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264EmitPictureParametersEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264EmitPictureParametersEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264EmitPictureParametersEXT.spsId );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264EmitPictureParametersEXT.emitSpsEnable );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264EmitPictureParametersEXT.ppsIdEntryCount );
+    VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, videoEncodeH264EmitPictureParametersEXT.ppsIdEntries );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -78694,6 +94235,25 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT(
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT>::value,
     "VideoEncodeH264FrameSizeEXT is not nothrow_move_constructible!" );
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT const & videoEncodeH264FrameSizeEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.frameISize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.framePSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.frameBSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -78876,6 +94436,34 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264NaluSliceEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT const & videoEncodeH264NaluSliceEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264NaluSliceEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264NaluSliceEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH264SliceHeader *, seed, videoEncodeH264NaluSliceEXT.pSliceHeaderStd );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264NaluSliceEXT.mbCount );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264NaluSliceEXT.refFinalList0EntryCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
+                             seed,
+                             videoEncodeH264NaluSliceEXT.pRefFinalList0Entries );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264NaluSliceEXT.refFinalList1EntryCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
+                             seed,
+                             videoEncodeH264NaluSliceEXT.pRefFinalList1Entries );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -78965,6 +94553,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264ProfileEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileEXT const & videoEncodeH264ProfileEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264ProfileEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264ProfileEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( StdVideoH264ProfileIdc, seed, videoEncodeH264ProfileEXT.stdProfileIdc );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -79050,6 +94657,25 @@ namespace VULKAN_HPP_NAMESPACE
                             "struct wrapper is not a standard layout!" );
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT>::value,
                             "VideoEncodeH264QpEXT is not nothrow_move_constructible!" );
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const & videoEncodeH264QpEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpI );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpP );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpB );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -79175,6 +94801,30 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264RateControlInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT const &
+                            videoEncodeH264RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264RateControlInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264RateControlInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.gopFrameCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.idrPeriod );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.consecutiveBFrameCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT,
+                             seed,
+                             videoEncodeH264RateControlInfoEXT.rateControlStructure );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -79354,6 +95004,39 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264RateControlLayerInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT const &
+                            videoEncodeH264RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264RateControlLayerInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264RateControlLayerInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264RateControlLayerInfoEXT.temporalLayerId );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useInitialRcQp );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.initialRcQp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMinQp );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.minQp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMaxQp );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.maxQp );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMaxFrameSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT, seed, videoEncodeH264RateControlLayerInfoEXT.maxFrameSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -79468,6 +95151,31 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264SessionCreateInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT const &
+                            videoEncodeH264SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH264CreateFlagsEXT, seed, videoEncodeH264SessionCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264SessionCreateInfoEXT.maxPictureSizeInMbs );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
+                             seed,
+                             videoEncodeH264SessionCreateInfoEXT.pStdExtensionVersion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -79629,6 +95337,31 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264SessionParametersAddInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT const &
+                            videoEncodeH264SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionParametersAddInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionParametersAddInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersAddInfoEXT.spsStdCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoH264SequenceParameterSet *, seed, videoEncodeH264SessionParametersAddInfoEXT.pSpsStd );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersAddInfoEXT.ppsStdCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoH264PictureParameterSet *, seed, videoEncodeH264SessionParametersAddInfoEXT.pPpsStd );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -79748,6 +95481,30 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264SessionParametersCreateInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT const &
+                            videoEncodeH264SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionParametersCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionParametersCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersCreateInfoEXT.maxSpsStdCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersCreateInfoEXT.maxPpsStdCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT *,
+                             seed,
+                             videoEncodeH264SessionParametersCreateInfoEXT.pParametersAddInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -79957,6 +95714,39 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH264VclFrameInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT const & videoEncodeH264VclFrameInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264VclFrameInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264VclFrameInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264VclFrameInfoEXT.refDefaultFinalList0EntryCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
+                             seed,
+                             videoEncodeH264VclFrameInfoEXT.pRefDefaultFinalList0Entries );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264VclFrameInfoEXT.refDefaultFinalList1EntryCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
+                             seed,
+                             videoEncodeH264VclFrameInfoEXT.pRefDefaultFinalList1Entries );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264VclFrameInfoEXT.naluSliceEntryCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT *,
+                             seed,
+                             videoEncodeH264VclFrameInfoEXT.pNaluSliceEntries );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
+                             seed,
+                             videoEncodeH264VclFrameInfoEXT.pCurrentPictureInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -80154,6 +95944,41 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265CapabilitiesEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT const & videoEncodeH265CapabilitiesEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265CapabilitiesEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265CapabilitiesEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.inputModeFlags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.outputModeFlags );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.ctbSizes );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH265CapabilitiesEXT.inputImageDataAlignment );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForP );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForB );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL1Reference );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumSubLayers );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.qualityLevelCount );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoEncodeH265CapabilitiesEXT.stdExtensionVersion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -80254,6 +96079,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265DpbSlotInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT const & videoEncodeH265DpbSlotInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265DpbSlotInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265DpbSlotInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoEncodeH265DpbSlotInfoEXT.slotIndex );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoEncodeH265ReferenceInfo *, seed, videoEncodeH265DpbSlotInfoEXT.pStdReferenceInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -80426,6 +96272,32 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265EmitPictureParametersEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265EmitPictureParametersEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265EmitPictureParametersEXT const &
+                            videoEncodeH265EmitPictureParametersEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265EmitPictureParametersEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265EmitPictureParametersEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265EmitPictureParametersEXT.vpsId );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265EmitPictureParametersEXT.spsId );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265EmitPictureParametersEXT.emitVpsEnable );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265EmitPictureParametersEXT.emitSpsEnable );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265EmitPictureParametersEXT.ppsIdEntryCount );
+    VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, videoEncodeH265EmitPictureParametersEXT.ppsIdEntries );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -80515,6 +96387,25 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_STATIC_ASSERT(
     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT>::value,
     "VideoEncodeH265FrameSizeEXT is not nothrow_move_constructible!" );
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const & videoEncodeH265FrameSizeEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.frameISize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.framePSize );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.frameBSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -80688,6 +96579,36 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265ReferenceListsEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT const & videoEncodeH265ReferenceListsEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265ReferenceListsEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265ReferenceListsEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265ReferenceListsEXT.referenceList0EntryCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT *,
+                             seed,
+                             videoEncodeH265ReferenceListsEXT.pReferenceList0Entries );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265ReferenceListsEXT.referenceList1EntryCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT *,
+                             seed,
+                             videoEncodeH265ReferenceListsEXT.pReferenceList1Entries );
+    VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH265ReferenceModifications *,
+                             seed,
+                             videoEncodeH265ReferenceListsEXT.pReferenceModifications );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -80798,6 +96719,29 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265NaluSliceEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT const & videoEncodeH265NaluSliceEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265NaluSliceEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265NaluSliceEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265NaluSliceEXT.ctbCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT *,
+                             seed,
+                             videoEncodeH265NaluSliceEXT.pReferenceFinalLists );
+    VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH265SliceHeader *, seed, videoEncodeH265NaluSliceEXT.pSliceHeaderStd );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -80887,6 +96831,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265ProfileEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileEXT const & videoEncodeH265ProfileEXT ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265ProfileEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265ProfileEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( StdVideoH265ProfileIdc, seed, videoEncodeH265ProfileEXT.stdProfileIdc );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -80972,6 +96935,25 @@ namespace VULKAN_HPP_NAMESPACE
                             "struct wrapper is not a standard layout!" );
   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT>::value,
                             "VideoEncodeH265QpEXT is not nothrow_move_constructible!" );
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & videoEncodeH265QpEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpI );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpP );
+    VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpB );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -81097,6 +97079,30 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265RateControlInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT const &
+                            videoEncodeH265RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265RateControlInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265RateControlInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.gopFrameCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.idrPeriod );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.consecutiveBFrameCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT,
+                             seed,
+                             videoEncodeH265RateControlInfoEXT.rateControlStructure );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -81276,6 +97282,39 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265RateControlLayerInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT const &
+                            videoEncodeH265RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265RateControlLayerInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265RateControlLayerInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265RateControlLayerInfoEXT.temporalId );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useInitialRcQp );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.initialRcQp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMinQp );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.minQp );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMaxQp );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.maxQp );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMaxFrameSize );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT, seed, videoEncodeH265RateControlLayerInfoEXT.maxFrameSize );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -81380,6 +97419,29 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265SessionCreateInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT const &
+                            videoEncodeH265SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeH265CreateFlagsEXT, seed, videoEncodeH265SessionCreateInfoEXT.flags );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
+                             seed,
+                             videoEncodeH265SessionCreateInfoEXT.pStdExtensionVersion );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -81576,6 +97638,34 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265SessionParametersAddInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT const &
+                            videoEncodeH265SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionParametersAddInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionParametersAddInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.vpsStdCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoH265VideoParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pVpsStd );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.spsStdCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoH265SequenceParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pSpsStd );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.ppsStdCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoH265PictureParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pPpsStd );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -81706,6 +97796,31 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265SessionParametersCreateInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT const &
+                            videoEncodeH265SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionParametersCreateInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionParametersCreateInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxVpsStdCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxSpsStdCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxPpsStdCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT *,
+                             seed,
+                             videoEncodeH265SessionParametersCreateInfoEXT.pParametersAddInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -81853,6 +97968,33 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeH265VclFrameInfoEXT;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT const & videoEncodeH265VclFrameInfoEXT )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265VclFrameInfoEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265VclFrameInfoEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT *,
+                             seed,
+                             videoEncodeH265VclFrameInfoEXT.pReferenceFinalLists );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265VclFrameInfoEXT.naluSliceEntryCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT *,
+                             seed,
+                             videoEncodeH265VclFrameInfoEXT.pNaluSliceEntries );
+    VULKAN_HPP_HASH_COMBINE(
+      const StdVideoEncodeH265PictureInfo *, seed, videoEncodeH265VclFrameInfoEXT.pCurrentPictureInfo );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -82084,6 +98226,38 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR, seed, videoEncodeInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.qualityLevel );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeInfoKHR.codedExtent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, videoEncodeInfoKHR.dstBitstreamBuffer );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoEncodeInfoKHR.dstBitstreamBufferOffset );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoEncodeInfoKHR.dstBitstreamBufferMaxRange );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR, seed, videoEncodeInfoKHR.srcPictureResource );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoEncodeInfoKHR.pSetupReferenceSlot );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.referenceSlotCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoEncodeInfoKHR.pReferenceSlots );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -82231,6 +98405,30 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeRateControlLayerInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const &
+                            videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeRateControlLayerInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeRateControlLayerInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.averageBitrate );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.maxBitrate );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.virtualBufferSizeInMs );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.initialVirtualBufferSizeInMs );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -82379,6 +98577,33 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEncodeRateControlInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeRateControlInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeRateControlInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR, seed, videoEncodeRateControlInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR,
+                             seed,
+                             videoEncodeRateControlInfoKHR.rateControlMode );
+    VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeRateControlInfoKHR.layerCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR *,
+                             seed,
+                             videoEncodeRateControlInfoKHR.pLayerConfigs );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -82466,6 +98691,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoEndCodingInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEndCodingInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEndCodingInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEndCodingFlagsKHR, seed, videoEndCodingInfoKHR.flags );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -82539,6 +98783,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoFormatPropertiesKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoFormatPropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, videoFormatPropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoFormatPropertiesKHR.format );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -82640,6 +98903,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoGetMemoryPropertiesKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR const & videoGetMemoryPropertiesKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoGetMemoryPropertiesKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoGetMemoryPropertiesKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoGetMemoryPropertiesKHR.memoryBindIndex );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 *, seed, videoGetMemoryPropertiesKHR.pMemoryRequirements );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -82731,6 +99015,26 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoQueueFamilyProperties2KHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoQueueFamilyProperties2KHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoQueueFamilyProperties2KHR const & videoQueueFamilyProperties2KHR )
+    const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoQueueFamilyProperties2KHR.sType );
+    VULKAN_HPP_HASH_COMBINE( void *, seed, videoQueueFamilyProperties2KHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagsKHR, seed, videoQueueFamilyProperties2KHR.videoCodecOperations );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -82895,6 +99199,33 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoSessionCreateInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.queueFamilyIndex );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagsKHR, seed, videoSessionCreateInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::VideoProfileKHR *, seed, videoSessionCreateInfoKHR.pVideoProfile );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoSessionCreateInfoKHR.pictureFormat );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoSessionCreateInfoKHR.maxCodedExtent );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoSessionCreateInfoKHR.referencePicturesFormat );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.maxReferencePicturesSlotsCount );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.maxReferencePicturesActiveCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -83000,6 +99331,29 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoSessionParametersCreateInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const &
+                            videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionParametersCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionParametersCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR,
+                             seed,
+                             videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::VideoSessionKHR, seed, videoSessionParametersCreateInfoKHR.videoSession );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -83092,6 +99446,25 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = VideoSessionParametersUpdateInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const &
+                            videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionParametersUpdateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionParametersUpdateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
@@ -83200,6 +99573,28 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = WaylandSurfaceCreateInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, waylandSurfaceCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, waylandSurfaceCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR, seed, waylandSurfaceCreateInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( struct wl_display *, seed, waylandSurfaceCreateInfoKHR.display );
+    VULKAN_HPP_HASH_COMBINE( struct wl_surface *, seed, waylandSurfaceCreateInfoKHR.surface );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -83462,6 +99857,33 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = Win32KeyedMutexAcquireReleaseInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const &
+                            win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32KeyedMutexAcquireReleaseInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs );
+    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs );
+    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -83726,6 +100148,33 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = Win32KeyedMutexAcquireReleaseInfoNV;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const &
+                            win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32KeyedMutexAcquireReleaseInfoNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, win32KeyedMutexAcquireReleaseInfoNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs );
+    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys );
+    VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount );
+    VULKAN_HPP_HASH_COMBINE(
+      const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs );
+    VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -83833,6 +100282,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = Win32SurfaceCreateInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32SurfaceCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, win32SurfaceCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR, seed, win32SurfaceCreateInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( HINSTANCE, seed, win32SurfaceCreateInfoKHR.hinstance );
+    VULKAN_HPP_HASH_COMBINE( HWND, seed, win32SurfaceCreateInfoKHR.hwnd );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct WriteDescriptorSet
@@ -84059,6 +100529,31 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = WriteDescriptorSet;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet>
+{
+  std::size_t
+    operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSet.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSet.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, writeDescriptorSet.dstSet );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.dstBinding );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.dstArrayElement );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.descriptorCount );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, writeDescriptorSet.descriptorType );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorImageInfo *, seed, writeDescriptorSet.pImageInfo );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorBufferInfo *, seed, writeDescriptorSet.pBufferInfo );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::BufferView *, seed, writeDescriptorSet.pTexelBufferView );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct WriteDescriptorSetAccelerationStructureKHR
   {
     using NativeType = VkWriteDescriptorSetAccelerationStructureKHR;
@@ -84186,6 +100681,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = WriteDescriptorSetAccelerationStructureKHR;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const &
+                            writeDescriptorSetAccelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetAccelerationStructureKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetAccelerationStructureKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *,
+                             seed,
+                             writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct WriteDescriptorSetAccelerationStructureNV
   {
     using NativeType = VkWriteDescriptorSetAccelerationStructureNV;
@@ -84313,6 +100830,28 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = WriteDescriptorSetAccelerationStructureNV;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const &
+                            writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE(
+      VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetAccelerationStructureNV.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetAccelerationStructureNV.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount );
+    VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AccelerationStructureNV *,
+                             seed,
+                             writeDescriptorSetAccelerationStructureNV.pAccelerationStructures );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
   struct WriteDescriptorSetInlineUniformBlockEXT
   {
     using NativeType = VkWriteDescriptorSetInlineUniformBlockEXT;
@@ -84434,6 +100973,25 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = WriteDescriptorSetInlineUniformBlockEXT;
   };
 
+}  // namespace VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlockEXT>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlockEXT const &
+                            writeDescriptorSetInlineUniformBlockEXT ) const VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetInlineUniformBlockEXT.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetInlineUniformBlockEXT.pNext );
+    VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetInlineUniformBlockEXT.dataSize );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetInlineUniformBlockEXT.pData );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #if defined( VK_USE_PLATFORM_XCB_KHR )
   struct XcbSurfaceCreateInfoKHR
   {
@@ -84539,6 +101097,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = XcbSurfaceCreateInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, xcbSurfaceCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, xcbSurfaceCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR, seed, xcbSurfaceCreateInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( xcb_connection_t *, seed, xcbSurfaceCreateInfoKHR.connection );
+    VULKAN_HPP_HASH_COMBINE( xcb_window_t, seed, xcbSurfaceCreateInfoKHR.window );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
 
 #if defined( VK_USE_PLATFORM_XLIB_KHR )
@@ -84645,6 +101224,27 @@ namespace VULKAN_HPP_NAMESPACE
   {
     using Type = XlibSurfaceCreateInfoKHR;
   };
+
+}  // VULKAN_HPP_NAMESPACE
+
+template <>
+struct std::hash<VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR>
+{
+  std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const
+    VULKAN_HPP_NOEXCEPT
+  {
+    std::size_t seed = 0;
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, xlibSurfaceCreateInfoKHR.sType );
+    VULKAN_HPP_HASH_COMBINE( const void *, seed, xlibSurfaceCreateInfoKHR.pNext );
+    VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR, seed, xlibSurfaceCreateInfoKHR.flags );
+    VULKAN_HPP_HASH_COMBINE( Display *, seed, xlibSurfaceCreateInfoKHR.dpy );
+    VULKAN_HPP_HASH_COMBINE( Window, seed, xlibSurfaceCreateInfoKHR.window );
+    return seed;
+  }
+};
+
+namespace VULKAN_HPP_NAMESPACE
+{
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
 }  // namespace VULKAN_HPP_NAMESPACE
diff --git a/registry/validusage.json b/registry/validusage.json
index 0291d7d..856fa2a 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.2.201",
-    "comment": "from git branch: github-main commit: d70e01c0be7b8a7d20b186b30b29a75b18bba75d",
-    "date": "2021-12-01 02:18:40Z"
+    "api version": "1.2.202",
+    "comment": "from git branch: github-main commit: 48b76697118c275337e49836259f0571b3410d84",
+    "date": "2021-12-07 08:44:26Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -3851,10 +3851,6 @@
           "text": " <code>stageMask</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkPipelineStageFlagBits2KHR\">VkPipelineStageFlagBits2KHR</a> values"
         },
         {
-          "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-requiredbitmask",
-          "text": " <code>stageMask</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
-        },
-        {
           "vuid": "VUID-vkCmdResetEvent2KHR-commandBuffer-recording",
           "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
         },
@@ -7240,7 +7236,7 @@
         },
         {
           "vuid": "VUID-VkAttachmentDescription-format-03280",
-          "text": " If <code>format</code> is a color format, <code>initialLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL</code>, <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL</code>, <code>VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL</code>, or <code>VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL</code>"
+          "text": " If <code>format</code> is a color format, <code>initialLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL</code> or <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL</code>"
         },
         {
           "vuid": "VUID-VkAttachmentDescription-format-03281",
@@ -7248,7 +7244,7 @@
         },
         {
           "vuid": "VUID-VkAttachmentDescription-format-03282",
-          "text": " If <code>format</code> is a color format, <code>finalLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL</code>, <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL</code>, <code>VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL</code>, or <code>VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL</code>"
+          "text": " If <code>format</code> is a color format, <code>finalLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL</code> or <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL</code>"
         },
         {
           "vuid": "VUID-VkAttachmentDescription-format-03283",
@@ -7291,6 +7287,16 @@
           "text": " <code>finalLayout</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkImageLayout\">VkImageLayout</a> value"
         }
       ],
+      "(VK_VERSION_1_1,VK_KHR_maintenance2)": [
+        {
+          "vuid": "VUID-VkAttachmentDescription-format-06487",
+          "text": " If <code>format</code> is a color format, <code>initialLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL</code> or <code>VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL</code>"
+        },
+        {
+          "vuid": "VUID-VkAttachmentDescription-format-06488",
+          "text": " If <code>format</code> is a color format, <code>finalLayout</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL</code> or <code>VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL</code>"
+        }
+      ],
       "(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [
         {
           "vuid": "VUID-VkAttachmentDescription-separateDepthStencilLayouts-03284",
@@ -10186,11 +10192,11 @@
         },
         {
           "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02755",
-          "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain, the <a href=\"#features-subgroupSizeControl\"><code>subgroupSizeControl</code></a> feature <strong class=\"purple\">must</strong> be enabled, and <code>stage</code> <strong class=\"purple\">must</strong> be a valid bit specified in <a href=\"#limits-required-subgroup-size-stages\"><code>requiredSubgroupSizeStages</code></a>"
+          "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain, the <a href=\"#features-subgroupSizeControl\"><code>subgroupSizeControl</code></a> feature <strong class=\"purple\">must</strong> be enabled, and <code>stage</code> <strong class=\"purple\">must</strong> be a valid bit specified in <a href=\"#limits-requiredSubgroupSizeStages\"><code>requiredSubgroupSizeStages</code></a>"
         },
         {
           "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02756",
-          "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain and <code>stage</code> is <code>VK_SHADER_STAGE_COMPUTE_BIT</code>, the local workgroup size of the shader <strong class=\"purple\">must</strong> be less than or equal to the product of <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a>::<code>requiredSubgroupSize</code> and <a href=\"#limits-max-subgroups-per-workgroup\"><code>maxComputeWorkgroupSubgroups</code></a>"
+          "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain and <code>stage</code> is <code>VK_SHADER_STAGE_COMPUTE_BIT</code>, the local workgroup size of the shader <strong class=\"purple\">must</strong> be less than or equal to the product of <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a>::<code>requiredSubgroupSize</code> and <a href=\"#limits-maxComputeWorkgroupSubgroups\"><code>maxComputeWorkgroupSubgroups</code></a>"
         },
         {
           "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02757",
@@ -10198,7 +10204,7 @@
         },
         {
           "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02758",
-          "text": " If <code>flags</code> has both the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> and <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flags set, the local workgroup size in the X dimension of the pipeline <strong class=\"purple\">must</strong> be a multiple of <a href=\"#limits-max-subgroup-size\"><code>maxSubgroupSize</code></a>"
+          "text": " If <code>flags</code> has both the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> and <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flags set, the local workgroup size in the X dimension of the pipeline <strong class=\"purple\">must</strong> be a multiple of <a href=\"#limits-maxSubgroupSize\"><code>maxSubgroupSize</code></a>"
         },
         {
           "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02759",
@@ -10214,11 +10220,11 @@
         },
         {
           "vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02761",
-          "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be greater or equal to <a href=\"#limits-min-subgroup-size\">minSubgroupSize</a>"
+          "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be greater or equal to <a href=\"#limits-minSubgroupSize\">minSubgroupSize</a>"
         },
         {
           "vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02762",
-          "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#limits-max-subgroup-size\">maxSubgroupSize</a>"
+          "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#limits-maxSubgroupSize\">maxSubgroupSize</a>"
         },
         {
           "vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-sType-sType",
@@ -10987,16 +10993,26 @@
           "text": " If <code>pStages</code> includes a fragment shader stage, and the fragment shader code enables <a href=\"#shaders-fragment-earlytest\">early fragment tests</a>, the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> <strong class=\"purple\">must</strong> not include <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM</code> or <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM</code>"
         },
         {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06467",
-          "text": " If the <code>flags</code> member of <a href=\"#VkPipelineColorBlendStateCreateInfo\">VkPipelineColorBlendStateCreateInfo</a> includes <code>VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM</code> <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM</code>"
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06484",
+          "text": " If the pipeline is being created with <a href=\"#pipeline-graphics-subsets-fragment-output\">fragment output interface state</a> and the <code>flags</code> member of <a href=\"#VkPipelineColorBlendStateCreateInfo\">VkPipelineColorBlendStateCreateInfo</a> includes <code>VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM</code> <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM</code>"
         },
         {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06468",
-          "text": " If the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> includes <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM</code>, <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM</code>"
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06485",
+          "text": " If the pipeline is being created with <a href=\"#pipeline-graphics-subsets-fragment-output\">fragment output interface state</a> and the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> includes <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM</code>, <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM</code>"
         },
         {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06469",
-          "text": " If the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> includes <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM</code>, <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM</code>"
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06486",
+          "text": " If the pipeline is being created with <a href=\"#pipeline-graphics-subsets-fragment-output\">fragment output interface state</a> and the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> includes <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM</code>, <code>subpass</code> <strong class=\"purple\">must</strong> have been created with <code>VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM</code>"
+        }
+      ],
+      "(VK_ARM_rasterization_order_attachment_access)+(VK_KHR_dynamic_rendering)": [
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06482",
+          "text": " If the pipeline is being created with <a href=\"#pipeline-graphics-subsets-fragment-output\">fragment output interface state</a> and the <code>flags</code> member of <a href=\"#VkPipelineColorBlendStateCreateInfo\">VkPipelineColorBlendStateCreateInfo</a> includes <code>VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM</code>, <code>renderpass</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
+        },
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06483",
+          "text": " If the pipeline is being created with <a href=\"#pipeline-graphics-subsets-fragment-output\">fragment output interface state</a> and the <code>flags</code> member of <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> includes <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM</code> or <code>VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM</code>, <code>renderpass</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         }
       ]
     },
@@ -16724,7 +16740,7 @@
         },
         {
           "vuid": "VUID-VkDeviceImageMemoryRequirementsKHR-pCreateInfo-06417",
-          "text": " If <code>pCreateInfo</code>::<code>flags</code> has <code>VK_IMAGE_CREATE_DISJOINT_BIT</code> set then <code>planAspect</code> <strong class=\"purple\">must</strong> not be zero"
+          "text": " If <code>pCreateInfo</code>::<code>flags</code> has <code>VK_IMAGE_CREATE_DISJOINT_BIT</code> set then <code>planeAspect</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_ASPECT_NONE_KHR</code>"
         },
         {
           "vuid": "VUID-VkDeviceImageMemoryRequirementsKHR-pCreateInfo-06419",
@@ -16750,7 +16766,7 @@
       "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_KHR_maintenance4)+(VK_EXT_image_drm_format_modifier)": [
         {
           "vuid": "VUID-VkDeviceImageMemoryRequirementsKHR-pCreateInfo-06418",
-          "text": " If <code>pCreateInfo</code>::<code>flags</code> has <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code> set then <code>planAspect</code> <strong class=\"purple\">must</strong> not be zero"
+          "text": " If <code>pCreateInfo</code>::<code>flags</code> has <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code> set then <code>planeAspect</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_ASPECT_NONE_KHR</code>"
         },
         {
           "vuid": "VUID-VkDeviceImageMemoryRequirementsKHR-pCreateInfo-06420",
@@ -22615,10 +22631,6 @@
           "text": " <code>stage</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkPipelineStageFlagBits2KHR\">VkPipelineStageFlagBits2KHR</a> values"
         },
         {
-          "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-requiredbitmask",
-          "text": " <code>stage</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
-        },
-        {
           "vuid": "VUID-vkCmdWriteTimestamp2KHR-queryPool-parameter",
           "text": " <code>queryPool</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkQueryPool\">VkQueryPool</a> handle"
         },
@@ -22777,6 +22789,18 @@
           "text": " If the <a href=\"#features-shadingRateImage\">shading rate image</a> feature is not enabled, <code>pipelineStage</code> <strong class=\"purple\">must</strong> not be <code>VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV</code>"
         }
       ],
+      "(VK_KHR_synchronization2)": [
+        {
+          "vuid": "VUID-vkCmdWriteTimestamp-synchronization2-06489",
+          "text": " If the <a href=\"#features-synchronization2\"><code>synchronization2</code></a> feature is not enabled, <code>pipelineStage</code> <strong class=\"purple\">must</strong> not be <code>VK_PIPELINE_STAGE_NONE_KHR</code>"
+        }
+      ],
+      "!(VK_KHR_synchronization2)": [
+        {
+          "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-06490",
+          "text": " <code>pipelineStage</code> <strong class=\"purple\">must</strong> not be <code>VK_PIPELINE_STAGE_NONE_KHR</code>"
+        }
+      ],
       "(VK_VERSION_1_1,VK_KHR_multiview)": [
         {
           "vuid": "VUID-vkCmdWriteTimestamp-None-00830",
@@ -26463,10 +26487,6 @@
           "text": " <code>stage</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkPipelineStageFlagBits2KHR\">VkPipelineStageFlagBits2KHR</a> values"
         },
         {
-          "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-requiredbitmask",
-          "text": " <code>stage</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
-        },
-        {
           "vuid": "VUID-vkCmdWriteBufferMarker2AMD-dstBuffer-parameter",
           "text": " <code>dstBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkBuffer\">VkBuffer</a> handle"
         },
@@ -26566,7 +26586,7 @@
         },
         {
           "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-parameter",
-          "text": " <code>pipelineStage</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPipelineStageFlagBits\">VkPipelineStageFlagBits</a> value"
+          "text": " If <code>pipelineStage</code> is not <code>0</code>, <code>pipelineStage</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPipelineStageFlagBits\">VkPipelineStageFlagBits</a> value"
         },
         {
           "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-parameter",
@@ -26614,6 +26634,18 @@
           "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-04081",
           "text": " If the <a href=\"#features-shadingRateImage\">shading rate image</a> feature is not enabled, <code>pipelineStage</code> <strong class=\"purple\">must</strong> not be <code>VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV</code>"
         }
+      ],
+      "(VK_AMD_buffer_marker)+(VK_KHR_synchronization2)": [
+        {
+          "vuid": "VUID-vkCmdWriteBufferMarkerAMD-synchronization2-06489",
+          "text": " If the <a href=\"#features-synchronization2\"><code>synchronization2</code></a> feature is not enabled, <code>pipelineStage</code> <strong class=\"purple\">must</strong> not be <code>VK_PIPELINE_STAGE_NONE_KHR</code>"
+        }
+      ],
+      "(VK_AMD_buffer_marker)+!(VK_KHR_synchronization2)": [
+        {
+          "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-06490",
+          "text": " <code>pipelineStage</code> <strong class=\"purple\">must</strong> not be <code>VK_PIPELINE_STAGE_NONE_KHR</code>"
+        }
       ]
     },
     "vkCmdResolveImage2KHR": {
@@ -47859,6 +47891,10 @@
         {
           "vuid": "VUID-StandaloneSpirv-Base-04781",
           "text": " The <code>Base</code> operand of any <code>OpBitCount</code>, <code>OpBitReverse</code>, <code>OpBitFieldInsert</code>, <code>OpBitFieldSExtract</code>, or <code>OpBitFieldUExtract</code> instruction <strong class=\"purple\">must</strong> be a 32-bit integer scalar or a vector of 32-bit integers"
+        },
+        {
+          "vuid": "VUID-StandaloneSpirv-DescriptorSet-06491",
+          "text": " If a variable is decorated by <code>DescriptorSet</code> or <code>Binding</code>, the storage class <strong class=\"purple\">must</strong> correspond to an entry in <a href=\"#interfaces-resources-storage-class-correspondence\">Shader Resource and Storage Class Correspondence</a>"
         }
       ],
       "(VK_VERSION_1_1)": [
diff --git a/registry/vk.xml b/registry/vk.xml
index b12875c..56b4890 100644
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -155,7 +155,7 @@ branch of the member gitlab server.
         <type category="define" requires="VK_MAKE_API_VERSION">// Vulkan 1.2 version number
 #define <name>VK_API_VERSION_1_2</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, 0)// Patch version should always be set to 0</type>
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 201</type>
+#define <name>VK_HEADER_VERSION</name> 202</type>
         <type 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, 2, VK_HEADER_VERSION)</type>
 
@@ -10228,7 +10228,7 @@ typedef void <name>CAMetalLayer</name>;
         <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdWriteBufferMarkerAMD</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
-            <param><type>VkPipelineStageFlagBits</type> <name>pipelineStage</name></param>
+            <param optional="true"><type>VkPipelineStageFlagBits</type> <name>pipelineStage</name></param>
             <param><type>VkBuffer</type> <name>dstBuffer</name></param>
             <param><type>VkDeviceSize</type> <name>dstOffset</name></param>
             <param><type>uint32_t</type> <name>marker</name></param>
@@ -11101,7 +11101,7 @@ typedef void <name>CAMetalLayer</name>;
             <proto><type>void</type> <name>vkCmdResetEvent2KHR</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type>                   <name>commandBuffer</name></param>
             <param><type>VkEvent</type>                                             <name>event</name></param>
-            <param><type>VkPipelineStageFlags2KHR</type>                            <name>stageMask</name></param>
+            <param optional="true"><type>VkPipelineStageFlags2KHR</type>            <name>stageMask</name></param>
         </command>
         <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdWaitEvents2KHR</name></proto>
@@ -11125,14 +11125,14 @@ typedef void <name>CAMetalLayer</name>;
         <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdWriteTimestamp2KHR</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type>                   <name>commandBuffer</name></param>
-            <param><type>VkPipelineStageFlags2KHR</type>                            <name>stage</name></param>
+            <param optional="true"><type>VkPipelineStageFlags2KHR</type>            <name>stage</name></param>
             <param><type>VkQueryPool</type>                                         <name>queryPool</name></param>
             <param><type>uint32_t</type>                                            <name>query</name></param>
         </command>
         <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdWriteBufferMarker2AMD</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type>                   <name>commandBuffer</name></param>
-            <param><type>VkPipelineStageFlags2KHR</type>                            <name>stage</name></param>
+            <param optional="true"><type>VkPipelineStageFlags2KHR</type>            <name>stage</name></param>
             <param><type>VkBuffer</type>                                            <name>dstBuffer</name></param>
             <param><type>VkDeviceSize</type>                                        <name>dstOffset</name></param>
             <param><type>uint32_t</type>                                            <name>marker</name></param>
@@ -17479,6 +17479,7 @@ typedef void <name>CAMetalLayer</name>;
                 <enum offset="1" extends="VkStructureType"                    name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR"/>
                 <enum offset="2" extends="VkStructureType"                    name="VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR"/>
                 <enum offset="3" extends="VkStructureType"                    name="VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR"/>
+                <enum value="0"  extends="VkImageAspectFlagBits"              name="VK_IMAGE_ASPECT_NONE_KHR"/>
                 <type name="VkPhysicalDeviceMaintenance4FeaturesKHR"/>
                 <type name="VkPhysicalDeviceMaintenance4PropertiesKHR"/>
                 <type name="VkDeviceBufferMemoryRequirementsKHR"/>
@@ -17634,6 +17635,12 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_EXT_extension_438&quot;"          name="VK_EXT_EXTENSION_438_EXTENSION_NAME"/>
             </require>
         </extension>
+        <extension name="VK_SEC_extension_439" number="439" author="SEC" contact="Ralph Potter gitlab:@r_potter" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_SEC_EXTENSION_439_SPEC_VERSION"/>
+                <enum value="&quot;VK_SEC_extension_439&quot;"          name="VK_SEC_EXTENSION_439_EXTENSION_NAME"/>
+            </require>
+        </extension>
     </extensions>
     <formats>
         <format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">