Update for Vulkan-Docs 1.2.139v1.2.139

5 files changed, 7467 insertions, 356 deletions

diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index 08be754..3da8746 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -82,7 +82,8 @@
 # include <compare>
 #endif
 
-static_assert( VK_HEADER_VERSION ==  137 , "Wrong VK_HEADER_VERSION!" );
+
+static_assert( VK_HEADER_VERSION ==  139 , "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
@@ -170,6 +171,12 @@ static_assert( VK_HEADER_VERSION ==  137 , "Wrong VK_HEADER_VERSION!" );
 # endif
 #endif
 
+#if __cplusplus >= 201402L
+#  define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]]
+#else
+#  define VULKAN_HPP_DEPRECATED( msg )
+#endif
+
 #if !defined(VULKAN_HPP_NAMESPACE)
 #define VULKAN_HPP_NAMESPACE vk
 #endif
@@ -180,19 +187,31 @@ static_assert( VK_HEADER_VERSION ==  137 , "Wrong VK_HEADER_VERSION!" );
 
 namespace VULKAN_HPP_NAMESPACE
 {
+
 #if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
   template <typename T>
   class ArrayProxy
   {
   public:
+    VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
+      : m_count(0)
+      , m_ptr(nullptr)
+    {}
+
     VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t) VULKAN_HPP_NOEXCEPT
       : m_count(0)
       , m_ptr(nullptr)
     {}
 
-    ArrayProxy(typename std::remove_reference<T>::type & ptr) VULKAN_HPP_NOEXCEPT
+    ArrayProxy(T & value) VULKAN_HPP_NOEXCEPT
+      : m_count(1)
+      , m_ptr(&value)
+    {}
+
+    template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy(typename std::remove_const<T>::type & value) VULKAN_HPP_NOEXCEPT
       : m_count(1)
-      , m_ptr(&ptr)
+      , m_ptr(&value)
     {}
 
     ArrayProxy(uint32_t count, T * ptr) VULKAN_HPP_NOEXCEPT
@@ -200,33 +219,44 @@ namespace VULKAN_HPP_NAMESPACE
       , m_ptr(ptr)
     {}
 
-    template <size_t N>
-    ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data) VULKAN_HPP_NOEXCEPT
-      : m_count(N)
-      , m_ptr(data.data())
+    template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy(uint32_t count, typename std::remove_const<T>::type * ptr) VULKAN_HPP_NOEXCEPT
+      : m_count(count)
+      , m_ptr(ptr)
+    {}
+
+    ArrayProxy(std::initializer_list<T> const& list) VULKAN_HPP_NOEXCEPT
+      : m_count(static_cast<uint32_t>(list.size()))
+      , m_ptr(list.begin())
     {}
 
-    template <size_t N>
-    ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data) VULKAN_HPP_NOEXCEPT
-      : m_count(N)
-      , m_ptr(data.data())
+    template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy(std::initializer_list<typename std::remove_const<T>::type> const& list) VULKAN_HPP_NOEXCEPT
+      : m_count(static_cast<uint32_t>(list.size()))
+      , m_ptr(list.begin())
     {}
 
-    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
-    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data) VULKAN_HPP_NOEXCEPT
-      : m_count(static_cast<uint32_t>(data.size()))
-      , m_ptr(data.data())
+    ArrayProxy(std::initializer_list<T> & list) VULKAN_HPP_NOEXCEPT
+      : m_count(static_cast<uint32_t>(list.size()))
+      , m_ptr(list.begin())
     {}
 
-    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
-    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data) VULKAN_HPP_NOEXCEPT
-      : m_count(static_cast<uint32_t>(data.size()))
-      , m_ptr(data.data())
+    template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy(std::initializer_list<typename std::remove_const<T>::type> & list) VULKAN_HPP_NOEXCEPT
+      : m_count(static_cast<uint32_t>(list.size()))
+      , m_ptr(list.begin())
     {}
 
-    ArrayProxy(std::initializer_list<typename std::remove_reference<T>::type> const& data) VULKAN_HPP_NOEXCEPT
-      : m_count(static_cast<uint32_t>(data.end() - data.begin()))
-      , m_ptr(data.begin())
+    template <typename Container>
+    ArrayProxy(Container const& container) VULKAN_HPP_NOEXCEPT
+      : m_count(static_cast<uint32_t>(container.size()))
+      , m_ptr(container.data())
+    {}
+
+    template <typename Container>
+    ArrayProxy(Container & container) VULKAN_HPP_NOEXCEPT
+      : m_count(static_cast<uint32_t>(container.size()))
+      , m_ptr(container.data())
     {}
 
     const T * begin() const VULKAN_HPP_NOEXCEPT
@@ -448,25 +478,25 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     // assignment operators
-    Flags<BitType> & operator=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
     {
       m_mask = rhs.m_mask;
       return *this;
     }
 
-    Flags<BitType> & operator|=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
     {
       m_mask |= rhs.m_mask;
       return *this;
     }
 
-    Flags<BitType> & operator&=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
     {
       m_mask &= rhs.m_mask;
       return *this;
     }
 
-    Flags<BitType> & operator^=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
     {
       m_mask ^= rhs.m_mask;
       return *this;
@@ -3213,6 +3243,10 @@ namespace VULKAN_HPP_NAMESPACE
   using DeviceSize = uint64_t;
   using SampleMask = uint32_t;
 
+  template <typename EnumType, EnumType value>
+  struct CppType
+  {};
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   enum class AccelerationStructureBuildTypeKHR
   {
@@ -6126,6 +6160,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  template<ObjectType value>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type
+  {};
+
   enum class PeerMemoryFeatureFlagBits : VkPeerMemoryFeatureFlags
   {
     eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
@@ -7936,6 +7974,8 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceTexelBufferAlignmentPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT,
     eCommandBufferInheritanceRenderPassTransformInfoQCOM = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM,
     eRenderPassTransformBeginInfoQCOM = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM,
+    ePhysicalDeviceRobustness2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
+    ePhysicalDeviceRobustness2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT,
     ePipelineLibraryCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR,
     ePhysicalDevicePipelineCreationCacheControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT,
     ePhysicalDeviceDiagnosticsConfigFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
@@ -8485,6 +8525,8 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT : return "PhysicalDeviceTexelBufferAlignmentPropertiesEXT";
       case StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM : return "CommandBufferInheritanceRenderPassTransformInfoQCOM";
       case StructureType::eRenderPassTransformBeginInfoQCOM : return "RenderPassTransformBeginInfoQCOM";
+      case StructureType::ePhysicalDeviceRobustness2FeaturesEXT : return "PhysicalDeviceRobustness2FeaturesEXT";
+      case StructureType::ePhysicalDeviceRobustness2PropertiesEXT : return "PhysicalDeviceRobustness2PropertiesEXT";
       case StructureType::ePipelineLibraryCreateInfoKHR : return "PipelineLibraryCreateInfoKHR";
       case StructureType::ePhysicalDevicePipelineCreationCacheControlFeaturesEXT : return "PhysicalDevicePipelineCreationCacheControlFeaturesEXT";
       case StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV : return "PhysicalDeviceDiagnosticsConfigFeaturesNV";
@@ -8542,7 +8584,9 @@ namespace VULKAN_HPP_NAMESPACE
   enum class SubpassDescriptionFlagBits : VkSubpassDescriptionFlags
   {
     ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX,
-    ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX
+    ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX,
+    eFragmentRegionQCOM = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM,
+    eShaderResolveQCOM = VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM
   };
 
   VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlagBits value )
@@ -8551,6 +8595,8 @@ namespace VULKAN_HPP_NAMESPACE
     {
       case SubpassDescriptionFlagBits::ePerViewAttributesNVX : return "PerViewAttributesNVX";
       case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX : return "PerViewPositionXOnlyNVX";
+      case SubpassDescriptionFlagBits::eFragmentRegionQCOM : return "FragmentRegionQCOM";
+      case SubpassDescriptionFlagBits::eShaderResolveQCOM : return "ShaderResolveQCOM";
       default: return "invalid";
     }
   }
@@ -8842,11 +8888,47 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
-  template<ObjectType value>
-  struct cpp_type
+  template<typename T>
+  struct IndexTypeValue
+  {};
+
+  template <>
+  struct IndexTypeValue<uint16_t>
+  {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint16;
+  };
+
+  template <>
+  struct CppType<IndexType, IndexType::eUint16>
+  {
+    using Type = uint16_t;
+  };
+
+  template <>
+  struct IndexTypeValue<uint32_t>
+  {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint32;
+  };
+
+  template <>
+  struct CppType<IndexType, IndexType::eUint32>
   {
+    using Type = uint32_t;
   };
 
+  template <>
+  struct IndexTypeValue<uint8_t>
+  {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint8EXT;
+  };
+
+  template <>
+  struct CppType<IndexType, IndexType::eUint8EXT>
+  {
+    using Type = uint8_t;
+  };
+
+
   using AccessFlags = Flags<AccessFlagBits>;
 
   template <> struct FlagTraits<AccessFlagBits>
@@ -8879,6 +8961,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( AccessFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -8913,10 +8996,12 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using AcquireProfilingLockFlagsKHR = Flags<AcquireProfilingLockFlagBitsKHR>;
 
   VULKAN_HPP_INLINE std::string to_string( AcquireProfilingLockFlagsKHR  )
   {
+
     return "{}";
   }
 
@@ -8933,10 +9018,12 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagsKHR  )
   {
+
     return "{}";
   }
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
+
   using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits>;
 
   template <> struct FlagTraits<AttachmentDescriptionFlagBits>
@@ -8969,6 +9056,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -8976,6 +9064,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using BufferCreateFlags = Flags<BufferCreateFlagBits>;
 
   template <> struct FlagTraits<BufferCreateFlagBits>
@@ -9008,6 +9097,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( BufferCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9019,6 +9109,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using BufferUsageFlags = Flags<BufferUsageFlagBits>;
 
   template <> struct FlagTraits<BufferUsageFlagBits>
@@ -9051,6 +9142,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9071,13 +9163,16 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using BuildAccelerationStructureFlagsKHR = Flags<BuildAccelerationStructureFlagBitsKHR>;
 
   template <> struct FlagTraits<BuildAccelerationStructureFlagBitsKHR>
@@ -9112,6 +9207,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagsKHR value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9123,6 +9219,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ColorComponentFlags = Flags<ColorComponentFlagBits>;
 
   template <> struct FlagTraits<ColorComponentFlagBits>
@@ -9155,6 +9252,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ColorComponentFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9165,6 +9263,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits>;
 
   template <> struct FlagTraits<CommandBufferResetFlagBits>
@@ -9197,6 +9296,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9204,6 +9304,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits>;
 
   template <> struct FlagTraits<CommandBufferUsageFlagBits>
@@ -9236,6 +9337,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( CommandBufferUsageFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9245,6 +9347,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits>;
 
   template <> struct FlagTraits<CommandPoolCreateFlagBits>
@@ -9277,6 +9380,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( CommandPoolCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9286,6 +9390,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits>;
 
   template <> struct FlagTraits<CommandPoolResetFlagBits>
@@ -9318,6 +9423,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9339,9 +9445,11 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlags  )
   {
+
     return "{}";
   }
 
+
   using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR>;
 
   template <> struct FlagTraits<CompositeAlphaFlagBitsKHR>
@@ -9374,6 +9482,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( CompositeAlphaFlagsKHR value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9384,6 +9493,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ConditionalRenderingFlagsEXT = Flags<ConditionalRenderingFlagBitsEXT>;
 
   template <> struct FlagTraits<ConditionalRenderingFlagBitsEXT>
@@ -9416,6 +9526,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ConditionalRenderingFlagsEXT value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9423,6 +9534,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using CullModeFlags = Flags<CullModeFlagBits>;
 
   template <> struct FlagTraits<CullModeFlagBits>
@@ -9455,6 +9567,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( CullModeFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9463,6 +9576,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT>;
 
   template <> struct FlagTraits<DebugReportFlagBitsEXT>
@@ -9495,6 +9609,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DebugReportFlagsEXT value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9506,6 +9621,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using DebugUtilsMessageSeverityFlagsEXT = Flags<DebugUtilsMessageSeverityFlagBitsEXT>;
 
   template <> struct FlagTraits<DebugUtilsMessageSeverityFlagBitsEXT>
@@ -9538,6 +9654,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageSeverityFlagsEXT value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9548,6 +9665,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using DebugUtilsMessageTypeFlagsEXT = Flags<DebugUtilsMessageTypeFlagBitsEXT>;
 
   template <> struct FlagTraits<DebugUtilsMessageTypeFlagBitsEXT>
@@ -9580,6 +9698,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageTypeFlagsEXT value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9601,6 +9720,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagsEXT  )
   {
+
     return "{}";
   }
 
@@ -9616,9 +9736,11 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagsEXT  )
   {
+
     return "{}";
   }
 
+
   using DependencyFlags = Flags<DependencyFlagBits>;
 
   template <> struct FlagTraits<DependencyFlagBits>
@@ -9651,6 +9773,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DependencyFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9660,6 +9783,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using DescriptorBindingFlags = Flags<DescriptorBindingFlagBits>;
 
   template <> struct FlagTraits<DescriptorBindingFlagBits>
@@ -9694,6 +9818,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DescriptorBindingFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9704,6 +9829,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits>;
 
   template <> struct FlagTraits<DescriptorPoolCreateFlagBits>
@@ -9736,6 +9862,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9756,9 +9883,11 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlags  )
   {
+
     return "{}";
   }
 
+
   using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits>;
 
   template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits>
@@ -9791,6 +9920,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9813,16 +9943,20 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using DeviceCreateFlags = Flags<DeviceCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using DeviceDiagnosticsConfigFlagsNV = Flags<DeviceDiagnosticsConfigFlagBitsNV>;
 
   template <> struct FlagTraits<DeviceDiagnosticsConfigFlagBitsNV>
@@ -9855,6 +9989,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DeviceDiagnosticsConfigFlagsNV value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9864,6 +9999,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using DeviceGroupPresentModeFlagsKHR = Flags<DeviceGroupPresentModeFlagBitsKHR>;
 
   template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHR>
@@ -9896,6 +10032,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DeviceGroupPresentModeFlagsKHR value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9906,6 +10043,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits>;
 
   template <> struct FlagTraits<DeviceQueueCreateFlagBits>
@@ -9938,6 +10076,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -9957,9 +10096,11 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagsKHR  )
   {
+
     return "{}";
   }
 
+
   using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR>;
 
   template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR>
@@ -9992,6 +10133,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DisplayPlaneAlphaFlagsKHR value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10014,6 +10156,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagsKHR  )
   {
+
     return "{}";
   }
 
@@ -10029,9 +10172,11 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( EventCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using ExternalFenceFeatureFlags = Flags<ExternalFenceFeatureFlagBits>;
 
   template <> struct FlagTraits<ExternalFenceFeatureFlagBits>
@@ -10066,6 +10211,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10074,6 +10220,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ExternalFenceHandleTypeFlags = Flags<ExternalFenceHandleTypeFlagBits>;
 
   template <> struct FlagTraits<ExternalFenceHandleTypeFlagBits>
@@ -10108,6 +10255,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ExternalFenceHandleTypeFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10118,6 +10266,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ExternalMemoryFeatureFlags = Flags<ExternalMemoryFeatureFlagBits>;
 
   template <> struct FlagTraits<ExternalMemoryFeatureFlagBits>
@@ -10152,6 +10301,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10161,6 +10311,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV>;
 
   template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV>
@@ -10193,6 +10344,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlagsNV value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10202,6 +10354,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ExternalMemoryHandleTypeFlags = Flags<ExternalMemoryHandleTypeFlagBits>;
 
   template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBits>
@@ -10236,6 +10389,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10253,6 +10407,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV>;
 
   template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV>
@@ -10285,6 +10440,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlagsNV value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10295,6 +10451,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ExternalSemaphoreFeatureFlags = Flags<ExternalSemaphoreFeatureFlagBits>;
 
   template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBits>
@@ -10329,6 +10486,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10337,6 +10495,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ExternalSemaphoreHandleTypeFlags = Flags<ExternalSemaphoreHandleTypeFlagBits>;
 
   template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBits>
@@ -10371,6 +10530,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreHandleTypeFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10382,6 +10542,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using FenceCreateFlags = Flags<FenceCreateFlagBits>;
 
   template <> struct FlagTraits<FenceCreateFlagBits>
@@ -10414,6 +10575,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( FenceCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10421,6 +10583,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using FenceImportFlags = Flags<FenceImportFlagBits>;
 
   template <> struct FlagTraits<FenceImportFlagBits>
@@ -10455,6 +10618,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( FenceImportFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10462,6 +10626,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using FormatFeatureFlags = Flags<FormatFeatureFlagBits>;
 
   template <> struct FlagTraits<FormatFeatureFlagBits>
@@ -10494,6 +10659,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10526,6 +10692,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits>;
 
   template <> struct FlagTraits<FramebufferCreateFlagBits>
@@ -10558,6 +10725,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10565,6 +10733,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using GeometryFlagsKHR = Flags<GeometryFlagBitsKHR>;
 
   template <> struct FlagTraits<GeometryFlagBitsKHR>
@@ -10599,6 +10768,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( GeometryFlagsKHR value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10607,6 +10777,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using GeometryInstanceFlagsKHR = Flags<GeometryInstanceFlagBitsKHR>;
 
   template <> struct FlagTraits<GeometryInstanceFlagBitsKHR>
@@ -10641,6 +10812,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( GeometryInstanceFlagsKHR value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10663,6 +10835,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagsEXT  )
   {
+
     return "{}";
   }
 
@@ -10679,10 +10852,12 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagsMVK  )
   {
+
     return "{}";
   }
 #endif /*VK_USE_PLATFORM_IOS_MVK*/
 
+
   using ImageAspectFlags = Flags<ImageAspectFlagBits>;
 
   template <> struct FlagTraits<ImageAspectFlagBits>
@@ -10715,6 +10890,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10732,6 +10908,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ImageCreateFlags = Flags<ImageCreateFlagBits>;
 
   template <> struct FlagTraits<ImageCreateFlagBits>
@@ -10764,6 +10941,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ImageCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10798,10 +10976,12 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagsFUCHSIA  )
   {
+
     return "{}";
   }
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+
   using ImageUsageFlags = Flags<ImageUsageFlagBits>;
 
   template <> struct FlagTraits<ImageUsageFlagBits>
@@ -10834,6 +11014,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ImageUsageFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10850,6 +11031,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits>;
 
   template <> struct FlagTraits<ImageViewCreateFlagBits>
@@ -10882,6 +11064,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10889,6 +11072,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using IndirectCommandsLayoutUsageFlagsNV = Flags<IndirectCommandsLayoutUsageFlagBitsNV>;
 
   template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNV>
@@ -10921,6 +11105,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsNV value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10930,6 +11115,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using IndirectStateFlagsNV = Flags<IndirectStateFlagBitsNV>;
 
   template <> struct FlagTraits<IndirectStateFlagBitsNV>
@@ -10962,6 +11148,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( IndirectStateFlagsNV value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -10969,10 +11156,12 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using InstanceCreateFlags = Flags<InstanceCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlags  )
   {
+
     return "{}";
   }
 
@@ -10989,10 +11178,12 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagsMVK  )
   {
+
     return "{}";
   }
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
 
+
   using MemoryAllocateFlags = Flags<MemoryAllocateFlagBits>;
 
   template <> struct FlagTraits<MemoryAllocateFlagBits>
@@ -11027,6 +11218,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11036,6 +11228,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using MemoryHeapFlags = Flags<MemoryHeapFlagBits>;
 
   template <> struct FlagTraits<MemoryHeapFlagBits>
@@ -11068,6 +11261,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11088,9 +11282,11 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags  )
   {
+
     return "{}";
   }
 
+
   using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits>;
 
   template <> struct FlagTraits<MemoryPropertyFlagBits>
@@ -11123,6 +11319,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11150,10 +11347,12 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( MetalSurfaceCreateFlagsEXT  )
   {
+
     return "{}";
   }
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
 
+
   using PeerMemoryFeatureFlags = Flags<PeerMemoryFeatureFlagBits>;
 
   template <> struct FlagTraits<PeerMemoryFeatureFlagBits>
@@ -11188,6 +11387,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PeerMemoryFeatureFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11198,6 +11398,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using PerformanceCounterDescriptionFlagsKHR = Flags<PerformanceCounterDescriptionFlagBitsKHR>;
 
   template <> struct FlagTraits<PerformanceCounterDescriptionFlagBitsKHR>
@@ -11230,6 +11431,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagsKHR value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11238,6 +11440,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits>;
 
   template <> struct FlagTraits<PipelineCacheCreateFlagBits>
@@ -11270,6 +11473,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11277,17 +11481,21 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using PipelineCompilerControlFlagsAMD = Flags<PipelineCompilerControlFlagBitsAMD>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineCompilerControlFlagsAMD  )
   {
+
     return "{}";
   }
 
@@ -11303,6 +11511,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagsNV  )
   {
+
     return "{}";
   }
 
@@ -11318,6 +11527,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineCoverageReductionStateCreateFlagsNV  )
   {
+
     return "{}";
   }
 
@@ -11333,9 +11543,11 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagsNV  )
   {
+
     return "{}";
   }
 
+
   using PipelineCreateFlags = Flags<PipelineCreateFlagBits>;
 
   template <> struct FlagTraits<PipelineCreateFlagBits>
@@ -11368,6 +11580,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11392,6 +11605,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using PipelineCreationFeedbackFlagsEXT = Flags<PipelineCreationFeedbackFlagBitsEXT>;
 
   template <> struct FlagTraits<PipelineCreationFeedbackFlagBitsEXT>
@@ -11424,6 +11638,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlagsEXT value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11433,10 +11648,12 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags  )
   {
+
     return "{}";
   }
 
@@ -11452,34 +11669,43 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagsEXT  )
   {
+
     return "{}";
   }
 
+
   using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlags  )
   {
+
     return "{}";
   }
 
@@ -11495,6 +11721,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagsEXT  )
   {
+
     return "{}";
   }
 
@@ -11510,13 +11737,16 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagsEXT  )
   {
+
     return "{}";
   }
 
+
   using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlags  )
   {
+
     return "{}";
   }
 
@@ -11532,9 +11762,11 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagsEXT  )
   {
+
     return "{}";
   }
 
+
   using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits>;
 
   template <> struct FlagTraits<PipelineShaderStageCreateFlagBits>
@@ -11567,6 +11799,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11575,6 +11808,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using PipelineStageFlags = Flags<PipelineStageFlagBits>;
 
   template <> struct FlagTraits<PipelineStageFlagBits>
@@ -11607,6 +11841,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11639,24 +11874,30 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlags  )
   {
+
     return "{}";
   }
 
@@ -11672,9 +11913,11 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagsNV  )
   {
+
     return "{}";
   }
 
+
   using QueryControlFlags = Flags<QueryControlFlagBits>;
 
   template <> struct FlagTraits<QueryControlFlagBits>
@@ -11707,6 +11950,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( QueryControlFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11714,6 +11958,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits>;
 
   template <> struct FlagTraits<QueryPipelineStatisticFlagBits>
@@ -11746,6 +11991,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( QueryPipelineStatisticFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11763,13 +12009,16 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using QueryResultFlags = Flags<QueryResultFlagBits>;
 
   template <> struct FlagTraits<QueryResultFlagBits>
@@ -11802,6 +12051,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( QueryResultFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11812,6 +12062,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using QueueFlags = Flags<QueueFlagBits>;
 
   template <> struct FlagTraits<QueueFlagBits>
@@ -11844,6 +12095,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( QueueFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11855,6 +12107,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits>;
 
   template <> struct FlagTraits<RenderPassCreateFlagBits>
@@ -11887,6 +12140,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11894,6 +12148,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ResolveModeFlags = Flags<ResolveModeFlagBits>;
 
   template <> struct FlagTraits<ResolveModeFlagBits>
@@ -11928,6 +12183,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ResolveModeFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11938,6 +12194,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using SampleCountFlags = Flags<SampleCountFlagBits>;
 
   template <> struct FlagTraits<SampleCountFlagBits>
@@ -11970,6 +12227,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( SampleCountFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -11983,6 +12241,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using SamplerCreateFlags = Flags<SamplerCreateFlagBits>;
 
   template <> struct FlagTraits<SamplerCreateFlagBits>
@@ -12015,6 +12274,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12023,13 +12283,16 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using SemaphoreImportFlags = Flags<SemaphoreImportFlagBits>;
 
   template <> struct FlagTraits<SemaphoreImportFlagBits>
@@ -12064,6 +12327,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12071,6 +12335,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using SemaphoreWaitFlags = Flags<SemaphoreWaitFlagBits>;
 
   template <> struct FlagTraits<SemaphoreWaitFlagBits>
@@ -12105,6 +12370,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( SemaphoreWaitFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12112,20 +12378,25 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ShaderCorePropertiesFlagsAMD = Flags<ShaderCorePropertiesFlagBitsAMD>;
 
   VULKAN_HPP_INLINE std::string to_string( ShaderCorePropertiesFlagsAMD  )
   {
+
     return "{}";
   }
 
+
   using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( ShaderModuleCreateFlags  )
   {
+
     return "{}";
   }
 
+
   using ShaderStageFlags = Flags<ShaderStageFlagBits>;
 
   template <> struct FlagTraits<ShaderStageFlagBits>
@@ -12158,6 +12429,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ShaderStageFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12178,6 +12450,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits>;
 
   template <> struct FlagTraits<SparseImageFormatFlagBits>
@@ -12210,6 +12483,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( SparseImageFormatFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12219,6 +12493,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits>;
 
   template <> struct FlagTraits<SparseMemoryBindFlagBits>
@@ -12251,6 +12526,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( SparseMemoryBindFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12258,6 +12534,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using StencilFaceFlags = Flags<StencilFaceFlagBits>;
 
   template <> struct FlagTraits<StencilFaceFlagBits>
@@ -12290,6 +12567,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( StencilFaceFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12311,10 +12589,12 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagsGGP  )
   {
+
     return "{}";
   }
 #endif /*VK_USE_PLATFORM_GGP*/
 
+
   using SubgroupFeatureFlags = Flags<SubgroupFeatureFlagBits>;
 
   template <> struct FlagTraits<SubgroupFeatureFlagBits>
@@ -12347,6 +12627,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( SubgroupFeatureFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12362,13 +12643,14 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits>;
 
   template <> struct FlagTraits<SubpassDescriptionFlagBits>
   {
     enum : VkFlags
     {
-      allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX)
+      allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) | VkFlags(SubpassDescriptionFlagBits::eFragmentRegionQCOM) | VkFlags(SubpassDescriptionFlagBits::eShaderResolveQCOM)
     };
   };
 
@@ -12394,14 +12676,18 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlags value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
     if ( value & SubpassDescriptionFlagBits::ePerViewAttributesNVX ) result += "PerViewAttributesNVX | ";
     if ( value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX ) result += "PerViewPositionXOnlyNVX | ";
+    if ( value & SubpassDescriptionFlagBits::eFragmentRegionQCOM ) result += "FragmentRegionQCOM | ";
+    if ( value & SubpassDescriptionFlagBits::eShaderResolveQCOM ) result += "ShaderResolveQCOM | ";
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT>;
 
   template <> struct FlagTraits<SurfaceCounterFlagBitsEXT>
@@ -12434,6 +12720,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagsEXT value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12441,6 +12728,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR>;
 
   template <> struct FlagTraits<SurfaceTransformFlagBitsKHR>
@@ -12473,6 +12761,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( SurfaceTransformFlagsKHR value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12488,6 +12777,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR>;
 
   template <> struct FlagTraits<SwapchainCreateFlagBitsKHR>
@@ -12520,6 +12810,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagsKHR value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12529,6 +12820,7 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+
   using ToolPurposeFlagsEXT = Flags<ToolPurposeFlagBitsEXT>;
 
   template <> struct FlagTraits<ToolPurposeFlagBitsEXT>
@@ -12561,6 +12853,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ToolPurposeFlagsEXT value  )
   {
+
     if ( !value ) return "{}";
     std::string result;
 
@@ -12586,6 +12879,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagsEXT  )
   {
+
     return "{}";
   }
 
@@ -12602,6 +12896,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagsNN  )
   {
+
     return "{}";
   }
 #endif /*VK_USE_PLATFORM_VI_NN*/
@@ -12619,6 +12914,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagsKHR  )
   {
+
     return "{}";
   }
 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
@@ -12636,6 +12932,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagsKHR  )
   {
+
     return "{}";
   }
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
@@ -12653,6 +12950,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagsKHR  )
   {
+
     return "{}";
   }
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
@@ -12670,6 +12968,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagsKHR  )
   {
+
     return "{}";
   }
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
@@ -12993,6 +13292,7 @@ namespace VULKAN_HPP_NAMESPACE
       : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {}
   };
 
+
   [[noreturn]] static void throwResultException( Result result, char const * message )
   {
     switch ( result )
@@ -13724,6 +14024,8 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
   struct PhysicalDeviceRayTracingPropertiesNV;
   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
+  struct PhysicalDeviceRobustness2FeaturesEXT;
+  struct PhysicalDeviceRobustness2PropertiesEXT;
   struct PhysicalDeviceSampleLocationsPropertiesEXT;
   struct PhysicalDeviceSamplerFilterMinmaxProperties;
   using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
@@ -14075,11 +14377,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eSurfaceKHR>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eSurfaceKHR>
   {
     using type = SurfaceKHR;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eSurfaceKHR>
+  {
+    using Type = SurfaceKHR;
+  };
+
   class DebugReportCallbackEXT
   {
   public:
@@ -14154,11 +14462,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eDebugReportCallbackEXT>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDebugReportCallbackEXT>
   {
     using type = DebugReportCallbackEXT;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eDebugReportCallbackEXT>
+  {
+    using Type = DebugReportCallbackEXT;
+  };
+
   class DebugUtilsMessengerEXT
   {
   public:
@@ -14233,11 +14547,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eDebugUtilsMessengerEXT>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDebugUtilsMessengerEXT>
   {
     using type = DebugUtilsMessengerEXT;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eDebugUtilsMessengerEXT>
+  {
+    using Type = DebugUtilsMessengerEXT;
+  };
+
   class DisplayKHR
   {
   public:
@@ -14312,11 +14632,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eDisplayKHR>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDisplayKHR>
   {
     using type = DisplayKHR;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eDisplayKHR>
+  {
+    using Type = DisplayKHR;
+  };
+
   class SwapchainKHR
   {
   public:
@@ -14391,11 +14717,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eSwapchainKHR>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eSwapchainKHR>
   {
     using type = SwapchainKHR;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eSwapchainKHR>
+  {
+    using Type = SwapchainKHR;
+  };
+
   class Semaphore
   {
   public:
@@ -14470,11 +14802,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eSemaphore>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eSemaphore>
   {
     using type = Semaphore;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eSemaphore>
+  {
+    using Type = Semaphore;
+  };
+
   class Fence
   {
   public:
@@ -14549,11 +14887,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eFence>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eFence>
   {
     using type = Fence;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eFence>
+  {
+    using Type = Fence;
+  };
+
   class PerformanceConfigurationINTEL
   {
   public:
@@ -14628,11 +14972,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( PerformanceConfigurationINTEL ) == sizeof( VkPerformanceConfigurationINTEL ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::ePerformanceConfigurationINTEL>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::ePerformanceConfigurationINTEL>
   {
     using type = PerformanceConfigurationINTEL;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::ePerformanceConfigurationINTEL>
+  {
+    using Type = PerformanceConfigurationINTEL;
+  };
+
   class QueryPool
   {
   public:
@@ -14707,11 +15057,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eQueryPool>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eQueryPool>
   {
     using type = QueryPool;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eQueryPool>
+  {
+    using Type = QueryPool;
+  };
+
   class Buffer
   {
   public:
@@ -14786,11 +15142,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eBuffer>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eBuffer>
   {
     using type = Buffer;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eBuffer>
+  {
+    using Type = Buffer;
+  };
+
   class PipelineLayout
   {
   public:
@@ -14865,11 +15227,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::ePipelineLayout>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::ePipelineLayout>
   {
     using type = PipelineLayout;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::ePipelineLayout>
+  {
+    using Type = PipelineLayout;
+  };
+
   class DescriptorSet
   {
   public:
@@ -14944,11 +15312,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eDescriptorSet>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDescriptorSet>
   {
     using type = DescriptorSet;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eDescriptorSet>
+  {
+    using Type = DescriptorSet;
+  };
+
   class Pipeline
   {
   public:
@@ -15023,11 +15397,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::ePipeline>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::ePipeline>
   {
     using type = Pipeline;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::ePipeline>
+  {
+    using Type = Pipeline;
+  };
+
   class ImageView
   {
   public:
@@ -15102,11 +15482,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eImageView>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eImageView>
   {
     using type = ImageView;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eImageView>
+  {
+    using Type = ImageView;
+  };
+
   class Image
   {
   public:
@@ -15181,11 +15567,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eImage>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eImage>
   {
     using type = Image;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eImage>
+  {
+    using Type = Image;
+  };
+
   class AccelerationStructureKHR
   {
   public:
@@ -15260,10 +15652,16 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( AccelerationStructureKHR ) == sizeof( VkAccelerationStructureKHR ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eAccelerationStructureKHR>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eAccelerationStructureKHR>
   {
     using type = AccelerationStructureKHR;
   };
+
+  template <>
+  struct CppType<ObjectType, ObjectType::eAccelerationStructureKHR>
+  {
+    using Type = AccelerationStructureKHR;
+  };
   using AccelerationStructureNV = AccelerationStructureKHR;
 
   class DescriptorUpdateTemplate
@@ -15340,10 +15738,16 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eDescriptorUpdateTemplate>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDescriptorUpdateTemplate>
   {
     using type = DescriptorUpdateTemplate;
   };
+
+  template <>
+  struct CppType<ObjectType, ObjectType::eDescriptorUpdateTemplate>
+  {
+    using Type = DescriptorUpdateTemplate;
+  };
   using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
 
   class Event
@@ -15420,11 +15824,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eEvent>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eEvent>
   {
     using type = Event;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eEvent>
+  {
+    using Type = Event;
+  };
+
   class CommandBuffer
   {
   public:
@@ -16077,11 +16487,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eCommandBuffer>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eCommandBuffer>
   {
     using type = CommandBuffer;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eCommandBuffer>
+  {
+    using Type = CommandBuffer;
+  };
+
   class DeviceMemory
   {
   public:
@@ -16156,11 +16572,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eDeviceMemory>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDeviceMemory>
   {
     using type = DeviceMemory;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eDeviceMemory>
+  {
+    using Type = DeviceMemory;
+  };
+
   class BufferView
   {
   public:
@@ -16235,11 +16657,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eBufferView>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eBufferView>
   {
     using type = BufferView;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eBufferView>
+  {
+    using Type = BufferView;
+  };
+
   class CommandPool
   {
   public:
@@ -16314,11 +16742,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eCommandPool>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eCommandPool>
   {
     using type = CommandPool;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eCommandPool>
+  {
+    using Type = CommandPool;
+  };
+
   class PipelineCache
   {
   public:
@@ -16393,11 +16827,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::ePipelineCache>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::ePipelineCache>
   {
     using type = PipelineCache;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::ePipelineCache>
+  {
+    using Type = PipelineCache;
+  };
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   class DeferredOperationKHR
   {
@@ -16473,10 +16913,16 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eDeferredOperationKHR>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDeferredOperationKHR>
   {
     using type = DeferredOperationKHR;
   };
+
+  template <>
+  struct CppType<ObjectType, ObjectType::eDeferredOperationKHR>
+  {
+    using Type = DeferredOperationKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   class DescriptorPool
@@ -16553,11 +16999,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eDescriptorPool>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDescriptorPool>
   {
     using type = DescriptorPool;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eDescriptorPool>
+  {
+    using Type = DescriptorPool;
+  };
+
   class DescriptorSetLayout
   {
   public:
@@ -16632,11 +17084,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eDescriptorSetLayout>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDescriptorSetLayout>
   {
     using type = DescriptorSetLayout;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eDescriptorSetLayout>
+  {
+    using Type = DescriptorSetLayout;
+  };
+
   class Framebuffer
   {
   public:
@@ -16711,11 +17169,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eFramebuffer>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eFramebuffer>
   {
     using type = Framebuffer;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eFramebuffer>
+  {
+    using Type = Framebuffer;
+  };
+
   class IndirectCommandsLayoutNV
   {
   public:
@@ -16790,11 +17254,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( IndirectCommandsLayoutNV ) == sizeof( VkIndirectCommandsLayoutNV ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eIndirectCommandsLayoutNV>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eIndirectCommandsLayoutNV>
   {
     using type = IndirectCommandsLayoutNV;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eIndirectCommandsLayoutNV>
+  {
+    using Type = IndirectCommandsLayoutNV;
+  };
+
   class RenderPass
   {
   public:
@@ -16869,11 +17339,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eRenderPass>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eRenderPass>
   {
     using type = RenderPass;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eRenderPass>
+  {
+    using Type = RenderPass;
+  };
+
   class Sampler
   {
   public:
@@ -16948,11 +17424,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eSampler>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eSampler>
   {
     using type = Sampler;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eSampler>
+  {
+    using Type = Sampler;
+  };
+
   class SamplerYcbcrConversion
   {
   public:
@@ -17027,10 +17509,16 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eSamplerYcbcrConversion>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eSamplerYcbcrConversion>
   {
     using type = SamplerYcbcrConversion;
   };
+
+  template <>
+  struct CppType<ObjectType, ObjectType::eSamplerYcbcrConversion>
+  {
+    using Type = SamplerYcbcrConversion;
+  };
   using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
 
   class ShaderModule
@@ -17107,11 +17595,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eShaderModule>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eShaderModule>
   {
     using type = ShaderModule;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eShaderModule>
+  {
+    using Type = ShaderModule;
+  };
+
   class ValidationCacheEXT
   {
   public:
@@ -17186,11 +17680,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eValidationCacheEXT>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eValidationCacheEXT>
   {
     using type = ValidationCacheEXT;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eValidationCacheEXT>
+  {
+    using Type = ValidationCacheEXT;
+  };
+
   class Queue
   {
   public:
@@ -17328,11 +17828,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eQueue>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eQueue>
   {
     using type = Queue;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eQueue>
+  {
+    using Type = Queue;
+  };
+
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   class Device;
   template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureKHR, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
@@ -19370,11 +19876,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eDevice>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDevice>
   {
     using type = Device;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eDevice>
+  {
+    using Type = Device;
+  };
+
   class DisplayModeKHR
   {
   public:
@@ -19449,11 +19961,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eDisplayModeKHR>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDisplayModeKHR>
   {
     using type = DisplayModeKHR;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eDisplayModeKHR>
+  {
+    using Type = DisplayModeKHR;
+  };
+
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch> class UniqueHandleTraits<Device, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; };
   using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@@ -20076,11 +20594,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::ePhysicalDevice>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::ePhysicalDevice>
   {
     using type = PhysicalDevice;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::ePhysicalDevice>
+  {
+    using Type = PhysicalDevice;
+  };
+
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   class Instance;
   template <typename Dispatch> class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch> { public: using deleter = ObjectDestroy<Instance, Dispatch>; };
@@ -20449,11 +20973,17 @@ namespace VULKAN_HPP_NAMESPACE
   static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" );
 
   template <>
-  struct cpp_type<ObjectType::eInstance>
+  struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eInstance>
   {
     using type = Instance;
   };
 
+  template <>
+  struct CppType<ObjectType, ObjectType::eInstance>
+  {
+    using Type = Instance;
+  };
+
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch> class UniqueHandleTraits<Instance, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; };
   using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@@ -20497,6 +21027,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct AabbPositionsKHR
   {
+
     VULKAN_HPP_CONSTEXPR AabbPositionsKHR( float minX_ = {},
                                            float minY_ = {},
                                            float minZ_ = {},
@@ -20558,6 +21089,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAabbPositionsKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAabbPositionsKHR*>( this );
@@ -20568,6 +21100,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAabbPositionsKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AabbPositionsKHR const& ) const = default;
 #else
@@ -20587,6 +21120,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     float minX = {};
     float minY = {};
@@ -20594,6 +21129,7 @@ namespace VULKAN_HPP_NAMESPACE
     float maxX = {};
     float maxY = {};
     float maxZ = {};
+
   };
   static_assert( sizeof( AabbPositionsKHR ) == sizeof( VkAabbPositionsKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AabbPositionsKHR>::value, "struct wrapper is not a standard layout!" );
@@ -20607,14 +21143,12 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     DeviceOrHostAddressConstKHR( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ = {} )
-    {
-      deviceAddress = deviceAddress_;
-    }
+      : deviceAddress( deviceAddress_ )
+    {}
 
     DeviceOrHostAddressConstKHR( const void* hostAddress_ )
-    {
-      hostAddress = hostAddress_;
-    }
+      : hostAddress( hostAddress_ )
+    {}
 
     DeviceOrHostAddressConstKHR & setDeviceAddress( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -20657,6 +21191,8 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct AccelerationStructureGeometryTrianglesDataKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR;
+
     AccelerationStructureGeometryTrianglesDataKHR( VULKAN_HPP_NAMESPACE::Format vertexFormat_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
                                                    VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR vertexData_ = {},
                                                    VULKAN_HPP_NAMESPACE::DeviceSize vertexStride_ = {},
@@ -20700,7 +21236,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureGeometryTrianglesDataKHR & setVertexData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR vertexData_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureGeometryTrianglesDataKHR & setVertexData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & vertexData_ ) VULKAN_HPP_NOEXCEPT
     {
       vertexData = vertexData_;
       return *this;
@@ -20718,18 +21254,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureGeometryTrianglesDataKHR & setIndexData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR indexData_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureGeometryTrianglesDataKHR & setIndexData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & indexData_ ) VULKAN_HPP_NOEXCEPT
     {
       indexData = indexData_;
       return *this;
     }
 
-    AccelerationStructureGeometryTrianglesDataKHR & setTransformData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR transformData_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureGeometryTrianglesDataKHR & setTransformData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & transformData_ ) VULKAN_HPP_NOEXCEPT
     {
       transformData = transformData_;
       return *this;
     }
 
+
     operator VkAccelerationStructureGeometryTrianglesDataKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureGeometryTrianglesDataKHR*>( this );
@@ -20740,6 +21277,9 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR*>( this );
     }
 
+
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR;
     const void* pNext = {};
@@ -20749,14 +21289,23 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::IndexType indexType = VULKAN_HPP_NAMESPACE::IndexType::eUint16;
     VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR indexData = {};
     VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR transformData = {};
+
   };
   static_assert( sizeof( AccelerationStructureGeometryTrianglesDataKHR ) == sizeof( VkAccelerationStructureGeometryTrianglesDataKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureGeometryTrianglesDataKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureGeometryTrianglesDataKHR>
+  {
+    using Type = AccelerationStructureGeometryTrianglesDataKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct AccelerationStructureGeometryAabbsDataKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryAabbsDataKHR;
+
     AccelerationStructureGeometryAabbsDataKHR( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data_ = {},
                                                VULKAN_HPP_NAMESPACE::DeviceSize stride_ = {} ) VULKAN_HPP_NOEXCEPT
       : data( data_ )
@@ -20786,7 +21335,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureGeometryAabbsDataKHR & setData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureGeometryAabbsDataKHR & setData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & data_ ) VULKAN_HPP_NOEXCEPT
     {
       data = data_;
       return *this;
@@ -20798,6 +21347,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAccelerationStructureGeometryAabbsDataKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureGeometryAabbsDataKHR*>( this );
@@ -20808,19 +21358,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR*>( this );
     }
 
+
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryAabbsDataKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data = {};
     VULKAN_HPP_NAMESPACE::DeviceSize stride = {};
+
   };
   static_assert( sizeof( AccelerationStructureGeometryAabbsDataKHR ) == sizeof( VkAccelerationStructureGeometryAabbsDataKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureGeometryAabbsDataKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureGeometryAabbsDataKHR>
+  {
+    using Type = AccelerationStructureGeometryAabbsDataKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct AccelerationStructureGeometryInstancesDataKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryInstancesDataKHR;
+
     AccelerationStructureGeometryInstancesDataKHR( VULKAN_HPP_NAMESPACE::Bool32 arrayOfPointers_ = {},
                                                    VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data_ = {} ) VULKAN_HPP_NOEXCEPT
       : arrayOfPointers( arrayOfPointers_ )
@@ -20856,12 +21418,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureGeometryInstancesDataKHR & setData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureGeometryInstancesDataKHR & setData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & data_ ) VULKAN_HPP_NOEXCEPT
     {
       data = data_;
       return *this;
     }
 
+
     operator VkAccelerationStructureGeometryInstancesDataKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureGeometryInstancesDataKHR*>( this );
@@ -20872,14 +21435,24 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR*>( this );
     }
 
+
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryInstancesDataKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 arrayOfPointers = {};
     VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data = {};
+
   };
   static_assert( sizeof( AccelerationStructureGeometryInstancesDataKHR ) == sizeof( VkAccelerationStructureGeometryInstancesDataKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureGeometryInstancesDataKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureGeometryInstancesDataKHR>
+  {
+    using Type = AccelerationStructureGeometryInstancesDataKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
@@ -20891,35 +21464,32 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     AccelerationStructureGeometryDataKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR triangles_ = {} )
-    {
-      triangles = triangles_;
-    }
+      : triangles( triangles_ )
+    {}
 
     AccelerationStructureGeometryDataKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR aabbs_ )
-    {
-      aabbs = aabbs_;
-    }
+      : aabbs( aabbs_ )
+    {}
 
     AccelerationStructureGeometryDataKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR instances_ )
-    {
-      instances = instances_;
-    }
+      : instances( instances_ )
+    {}
 
-    AccelerationStructureGeometryDataKHR & setTriangles( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR triangles_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureGeometryDataKHR & setTriangles( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR const & triangles_ ) VULKAN_HPP_NOEXCEPT
     {
-      triangles = triangles_;
+      memcpy( &triangles, &triangles_, sizeof(VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR));
       return *this;
     }
 
-    AccelerationStructureGeometryDataKHR & setAabbs( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR aabbs_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureGeometryDataKHR & setAabbs( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR const & aabbs_ ) VULKAN_HPP_NOEXCEPT
     {
-      aabbs = aabbs_;
+      memcpy( &aabbs, &aabbs_, sizeof(VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR));
       return *this;
     }
 
-    AccelerationStructureGeometryDataKHR & setInstances( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR instances_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureGeometryDataKHR & setInstances( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR const & instances_ ) VULKAN_HPP_NOEXCEPT
     {
-      instances = instances_;
+      memcpy( &instances, &instances_, sizeof(VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR));
       return *this;
     }
 
@@ -20954,6 +21524,8 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct AccelerationStructureGeometryKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryKHR;
+
     AccelerationStructureGeometryKHR( VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType_ = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles,
                                       VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR geometry_ = {},
                                       VULKAN_HPP_NAMESPACE::GeometryFlagsKHR flags_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -20991,7 +21563,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureGeometryKHR & setGeometry( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR geometry_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureGeometryKHR & setGeometry( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR const & geometry_ ) VULKAN_HPP_NOEXCEPT
     {
       geometry = geometry_;
       return *this;
@@ -21003,6 +21575,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAccelerationStructureGeometryKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureGeometryKHR*>( this );
@@ -21013,15 +21586,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureGeometryKHR*>( this );
     }
 
+
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles;
     VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR geometry = {};
     VULKAN_HPP_NAMESPACE::GeometryFlagsKHR flags = {};
+
   };
   static_assert( sizeof( AccelerationStructureGeometryKHR ) == sizeof( VkAccelerationStructureGeometryKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureGeometryKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureGeometryKHR>
+  {
+    using Type = AccelerationStructureGeometryKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
@@ -21033,14 +21616,12 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     DeviceOrHostAddressKHR( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ = {} )
-    {
-      deviceAddress = deviceAddress_;
-    }
+      : deviceAddress( deviceAddress_ )
+    {}
 
     DeviceOrHostAddressKHR( void* hostAddress_ )
-    {
-      hostAddress = hostAddress_;
-    }
+      : hostAddress( hostAddress_ )
+    {}
 
     DeviceOrHostAddressKHR & setDeviceAddress( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -21083,6 +21664,8 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct AccelerationStructureBuildGeometryInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureBuildGeometryInfoKHR;
+
     AccelerationStructureBuildGeometryInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR type_ = VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR::eTopLevel,
                                                VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsKHR flags_ = {},
                                                VULKAN_HPP_NAMESPACE::Bool32 update_ = {},
@@ -21174,12 +21757,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureBuildGeometryInfoKHR & setScratchData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR scratchData_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureBuildGeometryInfoKHR & setScratchData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const & scratchData_ ) VULKAN_HPP_NOEXCEPT
     {
       scratchData = scratchData_;
       return *this;
     }
 
+
     operator VkAccelerationStructureBuildGeometryInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR*>( this );
@@ -21190,6 +21774,9 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR*>( this );
     }
 
+
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureBuildGeometryInfoKHR;
     const void* pNext = {};
@@ -21202,14 +21789,22 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t geometryCount = {};
     const VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR* const* ppGeometries = {};
     VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR scratchData = {};
+
   };
   static_assert( sizeof( AccelerationStructureBuildGeometryInfoKHR ) == sizeof( VkAccelerationStructureBuildGeometryInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureBuildGeometryInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureBuildGeometryInfoKHR>
+  {
+    using Type = AccelerationStructureBuildGeometryInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct AccelerationStructureBuildOffsetInfoKHR
   {
+
     VULKAN_HPP_CONSTEXPR AccelerationStructureBuildOffsetInfoKHR( uint32_t primitiveCount_ = {},
                                                                   uint32_t primitiveOffset_ = {},
                                                                   uint32_t firstVertex_ = {},
@@ -21255,6 +21850,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAccelerationStructureBuildOffsetInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureBuildOffsetInfoKHR*>( this );
@@ -21265,6 +21861,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureBuildOffsetInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AccelerationStructureBuildOffsetInfoKHR const& ) const = default;
 #else
@@ -21282,11 +21879,14 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t primitiveCount = {};
     uint32_t primitiveOffset = {};
     uint32_t firstVertex = {};
     uint32_t transformOffset = {};
+
   };
   static_assert( sizeof( AccelerationStructureBuildOffsetInfoKHR ) == sizeof( VkAccelerationStructureBuildOffsetInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureBuildOffsetInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -21295,6 +21895,8 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct AccelerationStructureCreateGeometryTypeInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCreateGeometryTypeInfoKHR;
+
     VULKAN_HPP_CONSTEXPR AccelerationStructureCreateGeometryTypeInfoKHR( VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType_ = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles,
                                                                          uint32_t maxPrimitiveCount_ = {},
                                                                          VULKAN_HPP_NAMESPACE::IndexType indexType_ = VULKAN_HPP_NAMESPACE::IndexType::eUint16,
@@ -21368,6 +21970,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAccelerationStructureCreateGeometryTypeInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureCreateGeometryTypeInfoKHR*>( this );
@@ -21378,6 +21981,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureCreateGeometryTypeInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AccelerationStructureCreateGeometryTypeInfoKHR const& ) const = default;
 #else
@@ -21399,6 +22003,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureCreateGeometryTypeInfoKHR;
     const void* pNext = {};
@@ -21408,14 +22014,23 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t maxVertexCount = {};
     VULKAN_HPP_NAMESPACE::Format vertexFormat = VULKAN_HPP_NAMESPACE::Format::eUndefined;
     VULKAN_HPP_NAMESPACE::Bool32 allowsTransforms = {};
+
   };
   static_assert( sizeof( AccelerationStructureCreateGeometryTypeInfoKHR ) == sizeof( VkAccelerationStructureCreateGeometryTypeInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureCreateGeometryTypeInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureCreateGeometryTypeInfoKHR>
+  {
+    using Type = AccelerationStructureCreateGeometryTypeInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct AccelerationStructureCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoKHR( VULKAN_HPP_NAMESPACE::DeviceSize compactedSize_ = {},
                                                              VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR type_ = VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR::eTopLevel,
                                                              VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsKHR flags_ = {},
@@ -21489,6 +22104,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAccelerationStructureCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureCreateInfoKHR*>( this );
@@ -21499,6 +22115,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AccelerationStructureCreateInfoKHR const& ) const = default;
 #else
@@ -21520,6 +22137,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureCreateInfoKHR;
     const void* pNext = {};
@@ -21529,13 +22148,22 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t maxGeometryCount = {};
     const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateGeometryTypeInfoKHR* pGeometryInfos = {};
     VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress = {};
+
   };
   static_assert( sizeof( AccelerationStructureCreateInfoKHR ) == sizeof( VkAccelerationStructureCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureCreateInfoKHR>
+  {
+    using Type = AccelerationStructureCreateInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct GeometryTrianglesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryTrianglesNV;
+
     VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( VULKAN_HPP_NAMESPACE::Buffer vertexData_ = {},
                                               VULKAN_HPP_NAMESPACE::DeviceSize vertexOffset_ = {},
                                               uint32_t vertexCount_ = {},
@@ -21649,6 +22277,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkGeometryTrianglesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeometryTrianglesNV*>( this );
@@ -21659,6 +22288,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeometryTrianglesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( GeometryTrianglesNV const& ) const = default;
 #else
@@ -21685,6 +22315,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGeometryTrianglesNV;
     const void* pNext = {};
@@ -21699,12 +22331,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::IndexType indexType = VULKAN_HPP_NAMESPACE::IndexType::eUint16;
     VULKAN_HPP_NAMESPACE::Buffer transformData = {};
     VULKAN_HPP_NAMESPACE::DeviceSize transformOffset = {};
+
   };
   static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GeometryTrianglesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eGeometryTrianglesNV>
+  {
+    using Type = GeometryTrianglesNV;
+  };
+
   struct GeometryAABBNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryAabbNV;
+
     VULKAN_HPP_CONSTEXPR GeometryAABBNV( VULKAN_HPP_NAMESPACE::Buffer aabbData_ = {},
                                          uint32_t numAABBs_ = {},
                                          uint32_t stride_ = {},
@@ -21762,6 +22403,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkGeometryAABBNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeometryAABBNV*>( this );
@@ -21772,6 +22414,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeometryAABBNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( GeometryAABBNV const& ) const = default;
 #else
@@ -21791,6 +22434,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGeometryAabbNV;
     const void* pNext = {};
@@ -21798,12 +22443,20 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t numAABBs = {};
     uint32_t stride = {};
     VULKAN_HPP_NAMESPACE::DeviceSize offset = {};
+
   };
   static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GeometryAABBNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eGeometryAabbNV>
+  {
+    using Type = GeometryAABBNV;
+  };
+
   struct GeometryDataNV
   {
+
     VULKAN_HPP_CONSTEXPR GeometryDataNV( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV triangles_ = {},
                                          VULKAN_HPP_NAMESPACE::GeometryAABBNV aabbs_ = {} ) VULKAN_HPP_NOEXCEPT
       : triangles( triangles_ )
@@ -21821,18 +22474,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GeometryDataNV & setTriangles( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV triangles_ ) VULKAN_HPP_NOEXCEPT
+    GeometryDataNV & setTriangles( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & triangles_ ) VULKAN_HPP_NOEXCEPT
     {
       triangles = triangles_;
       return *this;
     }
 
-    GeometryDataNV & setAabbs( VULKAN_HPP_NAMESPACE::GeometryAABBNV aabbs_ ) VULKAN_HPP_NOEXCEPT
+    GeometryDataNV & setAabbs( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & aabbs_ ) VULKAN_HPP_NOEXCEPT
     {
       aabbs = aabbs_;
       return *this;
     }
 
+
     operator VkGeometryDataNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeometryDataNV*>( this );
@@ -21843,6 +22497,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeometryDataNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( GeometryDataNV const& ) const = default;
 #else
@@ -21858,15 +22513,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::GeometryTrianglesNV triangles = {};
     VULKAN_HPP_NAMESPACE::GeometryAABBNV aabbs = {};
+
   };
   static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GeometryDataNV>::value, "struct wrapper is not a standard layout!" );
 
   struct GeometryNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryNV;
+
     VULKAN_HPP_CONSTEXPR GeometryNV( VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType_ = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles,
                                      VULKAN_HPP_NAMESPACE::GeometryDataNV geometry_ = {},
                                      VULKAN_HPP_NAMESPACE::GeometryFlagsKHR flags_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -21904,7 +22564,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GeometryNV & setGeometry( VULKAN_HPP_NAMESPACE::GeometryDataNV geometry_ ) VULKAN_HPP_NOEXCEPT
+    GeometryNV & setGeometry( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometry_ ) VULKAN_HPP_NOEXCEPT
     {
       geometry = geometry_;
       return *this;
@@ -21916,6 +22576,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkGeometryNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeometryNV*>( this );
@@ -21926,6 +22587,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeometryNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( GeometryNV const& ) const = default;
 #else
@@ -21944,18 +22606,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGeometryNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles;
     VULKAN_HPP_NAMESPACE::GeometryDataNV geometry = {};
     VULKAN_HPP_NAMESPACE::GeometryFlagsKHR flags = {};
+
   };
   static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GeometryNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eGeometryNV>
+  {
+    using Type = GeometryNV;
+  };
+
   struct AccelerationStructureInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureInfoNV;
+
     VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV type_ = {},
                                                       VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsNV flags_ = {},
                                                       uint32_t instanceCount_ = {},
@@ -22021,6 +22694,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAccelerationStructureInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureInfoNV*>( this );
@@ -22031,6 +22705,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AccelerationStructureInfoNV const& ) const = default;
 #else
@@ -22051,6 +22726,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureInfoNV;
     const void* pNext = {};
@@ -22059,12 +22736,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t instanceCount = {};
     uint32_t geometryCount = {};
     const VULKAN_HPP_NAMESPACE::GeometryNV* pGeometries = {};
+
   };
   static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureInfoNV>
+  {
+    using Type = AccelerationStructureInfoNV;
+  };
+
   struct AccelerationStructureCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( VULKAN_HPP_NAMESPACE::DeviceSize compactedSize_ = {},
                                                             VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV info_ = {} ) VULKAN_HPP_NOEXCEPT
       : compactedSize( compactedSize_ )
@@ -22100,12 +22786,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureCreateInfoNV & setInfo( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV info_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureCreateInfoNV & setInfo( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & info_ ) VULKAN_HPP_NOEXCEPT
     {
       info = info_;
       return *this;
     }
 
+
     operator VkAccelerationStructureCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( this );
@@ -22116,6 +22803,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AccelerationStructureCreateInfoNV const& ) const = default;
 #else
@@ -22133,18 +22821,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceSize compactedSize = {};
     VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV info = {};
+
   };
   static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureCreateInfoNV>
+  {
+    using Type = AccelerationStructureCreateInfoNV;
+  };
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct AccelerationStructureDeviceAddressInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureDeviceAddressInfoKHR;
+
     VULKAN_HPP_CONSTEXPR AccelerationStructureDeviceAddressInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT
       : accelerationStructure( accelerationStructure_ )
     {}
@@ -22178,6 +22877,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAccelerationStructureDeviceAddressInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR*>( this );
@@ -22188,6 +22888,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AccelerationStructureDeviceAddressInfoKHR const& ) const = default;
 #else
@@ -22204,17 +22905,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureDeviceAddressInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure = {};
+
   };
   static_assert( sizeof( AccelerationStructureDeviceAddressInfoKHR ) == sizeof( VkAccelerationStructureDeviceAddressInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureDeviceAddressInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureDeviceAddressInfoKHR>
+  {
+    using Type = AccelerationStructureDeviceAddressInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct TransformMatrixKHR
   {
+
     VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR( std::array<std::array<float,4>,3> const& matrix_ = {} ) VULKAN_HPP_NOEXCEPT
       : matrix( matrix_ )
     {}
@@ -22236,6 +22947,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkTransformMatrixKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkTransformMatrixKHR*>( this );
@@ -22246,6 +22958,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkTransformMatrixKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( TransformMatrixKHR const& ) const = default;
 #else
@@ -22260,14 +22973,18 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ArrayWrapper2D<float, 3, 4> matrix = {};
+
   };
   static_assert( sizeof( TransformMatrixKHR ) == sizeof( VkTransformMatrixKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<TransformMatrixKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct AccelerationStructureInstanceKHR
   {
+
     VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR( VULKAN_HPP_NAMESPACE::TransformMatrixKHR transform_ = {},
                                                               uint32_t instanceCustomIndex_ = {},
                                                               uint32_t mask_ = {},
@@ -22293,7 +23010,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureInstanceKHR & setTransform( VULKAN_HPP_NAMESPACE::TransformMatrixKHR transform_ ) VULKAN_HPP_NOEXCEPT
+    AccelerationStructureInstanceKHR & setTransform( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transform_ ) VULKAN_HPP_NOEXCEPT
     {
       transform = transform_;
       return *this;
@@ -22329,6 +23046,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAccelerationStructureInstanceKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureInstanceKHR*>( this );
@@ -22339,6 +23057,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureInstanceKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AccelerationStructureInstanceKHR const& ) const = default;
 #else
@@ -22358,6 +23077,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::TransformMatrixKHR transform = {};
     uint32_t instanceCustomIndex : 24;
@@ -22365,6 +23086,7 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t instanceShaderBindingTableRecordOffset : 24;
     VkGeometryInstanceFlagsKHR flags : 8;
     uint64_t accelerationStructureReference = {};
+
   };
   static_assert( sizeof( AccelerationStructureInstanceKHR ) == sizeof( VkAccelerationStructureInstanceKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureInstanceKHR>::value, "struct wrapper is not a standard layout!" );
@@ -22372,6 +23094,8 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct AccelerationStructureMemoryRequirementsInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureMemoryRequirementsInfoKHR;
+
     VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeKHR type_ = VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeKHR::eObject,
                                                                          VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType_ = VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR::eHost,
                                                                          VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -22421,6 +23145,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAccelerationStructureMemoryRequirementsInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoKHR*>( this );
@@ -22431,6 +23156,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AccelerationStructureMemoryRequirementsInfoKHR const& ) const = default;
 #else
@@ -22449,19 +23175,30 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeKHR type = VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeKHR::eObject;
     VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType = VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR::eHost;
     VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure = {};
+
   };
   static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoKHR ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureMemoryRequirementsInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureMemoryRequirementsInfoKHR>
+  {
+    using Type = AccelerationStructureMemoryRequirementsInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct AccelerationStructureMemoryRequirementsInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;
+
     VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV type_ = {},
                                                                         VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT
       : type( type_ )
@@ -22503,6 +23240,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAccelerationStructureMemoryRequirementsInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( this );
@@ -22513,6 +23251,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AccelerationStructureMemoryRequirementsInfoNV const& ) const = default;
 #else
@@ -22530,18 +23269,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV type = {};
     VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure = {};
+
   };
   static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureMemoryRequirementsInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureMemoryRequirementsInfoNV>
+  {
+    using Type = AccelerationStructureMemoryRequirementsInfoNV;
+  };
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct AccelerationStructureVersionKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureVersionKHR;
+
     VULKAN_HPP_CONSTEXPR AccelerationStructureVersionKHR( const uint8_t* versionData_ = {} ) VULKAN_HPP_NOEXCEPT
       : versionData( versionData_ )
     {}
@@ -22575,6 +23325,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAccelerationStructureVersionKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAccelerationStructureVersionKHR*>( this );
@@ -22585,6 +23336,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureVersionKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AccelerationStructureVersionKHR const& ) const = default;
 #else
@@ -22601,17 +23353,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureVersionKHR;
     const void* pNext = {};
     const uint8_t* versionData = {};
+
   };
   static_assert( sizeof( AccelerationStructureVersionKHR ) == sizeof( VkAccelerationStructureVersionKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureVersionKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAccelerationStructureVersionKHR>
+  {
+    using Type = AccelerationStructureVersionKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct AcquireNextImageInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAcquireNextImageInfoKHR;
+
     VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain_ = {},
                                                   uint64_t timeout_ = {},
                                                   VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {},
@@ -22677,6 +23440,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAcquireNextImageInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAcquireNextImageInfoKHR*>( this );
@@ -22687,6 +23451,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAcquireNextImageInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AcquireNextImageInfoKHR const& ) const = default;
 #else
@@ -22707,6 +23472,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAcquireNextImageInfoKHR;
     const void* pNext = {};
@@ -22715,12 +23482,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Semaphore semaphore = {};
     VULKAN_HPP_NAMESPACE::Fence fence = {};
     uint32_t deviceMask = {};
+
   };
   static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AcquireNextImageInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eAcquireNextImageInfoKHR>
+  {
+    using Type = AcquireNextImageInfoKHR;
+  };
+
   struct AcquireProfilingLockInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAcquireProfilingLockInfoKHR;
+
     VULKAN_HPP_CONSTEXPR AcquireProfilingLockInfoKHR( VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR flags_ = {},
                                                       uint64_t timeout_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -22762,6 +23538,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAcquireProfilingLockInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAcquireProfilingLockInfoKHR*>( this );
@@ -22772,6 +23549,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAcquireProfilingLockInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AcquireProfilingLockInfoKHR const& ) const = default;
 #else
@@ -22789,17 +23567,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAcquireProfilingLockInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR flags = {};
     uint64_t timeout = {};
+
   };
   static_assert( sizeof( AcquireProfilingLockInfoKHR ) == sizeof( VkAcquireProfilingLockInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AcquireProfilingLockInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eAcquireProfilingLockInfoKHR>
+  {
+    using Type = AcquireProfilingLockInfoKHR;
+  };
+
   struct AllocationCallbacks
   {
+
     VULKAN_HPP_CONSTEXPR AllocationCallbacks( void* pUserData_ = {},
                                               PFN_vkAllocationFunction pfnAllocation_ = {},
                                               PFN_vkReallocationFunction pfnReallocation_ = {},
@@ -22861,6 +23649,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAllocationCallbacks const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAllocationCallbacks*>( this );
@@ -22871,6 +23660,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAllocationCallbacks*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AllocationCallbacks const& ) const = default;
 #else
@@ -22890,6 +23680,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     void* pUserData = {};
     PFN_vkAllocationFunction pfnAllocation = {};
@@ -22897,12 +23689,14 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkFreeFunction pfnFree = {};
     PFN_vkInternalAllocationNotification pfnInternalAllocation = {};
     PFN_vkInternalFreeNotification pfnInternalFree = {};
+
   };
   static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AllocationCallbacks>::value, "struct wrapper is not a standard layout!" );
 
   struct ComponentMapping
   {
+
     VULKAN_HPP_CONSTEXPR ComponentMapping( VULKAN_HPP_NAMESPACE::ComponentSwizzle r_ = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity,
                                            VULKAN_HPP_NAMESPACE::ComponentSwizzle g_ = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity,
                                            VULKAN_HPP_NAMESPACE::ComponentSwizzle b_ = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity,
@@ -22948,6 +23742,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkComponentMapping const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkComponentMapping*>( this );
@@ -22958,6 +23753,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkComponentMapping*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ComponentMapping const& ) const = default;
 #else
@@ -22975,11 +23771,14 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ComponentSwizzle r = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity;
     VULKAN_HPP_NAMESPACE::ComponentSwizzle g = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity;
     VULKAN_HPP_NAMESPACE::ComponentSwizzle b = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity;
     VULKAN_HPP_NAMESPACE::ComponentSwizzle a = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity;
+
   };
   static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ComponentMapping>::value, "struct wrapper is not a standard layout!" );
@@ -22987,6 +23786,8 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   struct AndroidHardwareBufferFormatPropertiesANDROID
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;
+
     VULKAN_HPP_CONSTEXPR AndroidHardwareBufferFormatPropertiesANDROID( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
                                                                        uint64_t externalFormat_ = {},
                                                                        VULKAN_HPP_NAMESPACE::FormatFeatureFlags formatFeatures_ = {},
@@ -23022,6 +23823,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAndroidHardwareBufferFormatPropertiesANDROID const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>( this );
@@ -23032,6 +23834,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AndroidHardwareBufferFormatPropertiesANDROID const& ) const = default;
 #else
@@ -23055,6 +23858,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;
     void* pNext = {};
@@ -23066,14 +23871,23 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::SamplerYcbcrRange suggestedYcbcrRange = VULKAN_HPP_NAMESPACE::SamplerYcbcrRange::eItuFull;
     VULKAN_HPP_NAMESPACE::ChromaLocation suggestedXChromaOffset = VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven;
     VULKAN_HPP_NAMESPACE::ChromaLocation suggestedYChromaOffset = VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven;
+
   };
   static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AndroidHardwareBufferFormatPropertiesANDROID>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAndroidHardwareBufferFormatPropertiesANDROID>
+  {
+    using Type = AndroidHardwareBufferFormatPropertiesANDROID;
+  };
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   struct AndroidHardwareBufferPropertiesANDROID
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferPropertiesANDROID;
+
     VULKAN_HPP_CONSTEXPR AndroidHardwareBufferPropertiesANDROID( VULKAN_HPP_NAMESPACE::DeviceSize allocationSize_ = {},
                                                                  uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT
       : allocationSize( allocationSize_ )
@@ -23097,6 +23911,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAndroidHardwareBufferPropertiesANDROID const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>( this );
@@ -23107,6 +23922,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AndroidHardwareBufferPropertiesANDROID const& ) const = default;
 #else
@@ -23124,19 +23940,30 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceSize allocationSize = {};
     uint32_t memoryTypeBits = {};
+
   };
   static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AndroidHardwareBufferPropertiesANDROID>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAndroidHardwareBufferPropertiesANDROID>
+  {
+    using Type = AndroidHardwareBufferPropertiesANDROID;
+  };
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   struct AndroidHardwareBufferUsageANDROID
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferUsageANDROID;
+
     VULKAN_HPP_CONSTEXPR AndroidHardwareBufferUsageANDROID( uint64_t androidHardwareBufferUsage_ = {} ) VULKAN_HPP_NOEXCEPT
       : androidHardwareBufferUsage( androidHardwareBufferUsage_ )
     {}
@@ -23158,6 +23985,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAndroidHardwareBufferUsageANDROID const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>( this );
@@ -23168,6 +23996,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AndroidHardwareBufferUsageANDROID const& ) const = default;
 #else
@@ -23184,18 +24013,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID;
     void* pNext = {};
     uint64_t androidHardwareBufferUsage = {};
+
   };
   static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AndroidHardwareBufferUsageANDROID>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAndroidHardwareBufferUsageANDROID>
+  {
+    using Type = AndroidHardwareBufferUsageANDROID;
+  };
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   struct AndroidSurfaceCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidSurfaceCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR flags_ = {},
                                                       struct ANativeWindow* window_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -23237,6 +24077,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAndroidSurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( this );
@@ -23247,6 +24088,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AndroidSurfaceCreateInfoKHR const& ) const = default;
 #else
@@ -23264,18 +24106,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR flags = {};
     struct ANativeWindow* window = {};
+
   };
   static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AndroidSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eAndroidSurfaceCreateInfoKHR>
+  {
+    using Type = AndroidSurfaceCreateInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct ApplicationInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eApplicationInfo;
+
     VULKAN_HPP_CONSTEXPR ApplicationInfo( const char* pApplicationName_ = {},
                                           uint32_t applicationVersion_ = {},
                                           const char* pEngineName_ = {},
@@ -23341,6 +24194,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkApplicationInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkApplicationInfo*>( this );
@@ -23351,6 +24205,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkApplicationInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ApplicationInfo const& ) const = default;
 #else
@@ -23371,6 +24226,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eApplicationInfo;
     const void* pNext = {};
@@ -23379,12 +24236,20 @@ namespace VULKAN_HPP_NAMESPACE
     const char* pEngineName = {};
     uint32_t engineVersion = {};
     uint32_t apiVersion = {};
+
   };
   static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ApplicationInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eApplicationInfo>
+  {
+    using Type = ApplicationInfo;
+  };
+
   struct AttachmentDescription
   {
+
     VULKAN_HPP_CONSTEXPR AttachmentDescription( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags flags_ = {},
                                                 VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
                                                 VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1,
@@ -23470,6 +24335,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAttachmentDescription const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentDescription*>( this );
@@ -23480,6 +24346,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentDescription*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AttachmentDescription const& ) const = default;
 #else
@@ -23502,6 +24369,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags flags = {};
     VULKAN_HPP_NAMESPACE::Format format = VULKAN_HPP_NAMESPACE::Format::eUndefined;
@@ -23512,12 +24381,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::AttachmentStoreOp stencilStoreOp = VULKAN_HPP_NAMESPACE::AttachmentStoreOp::eStore;
     VULKAN_HPP_NAMESPACE::ImageLayout initialLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
     VULKAN_HPP_NAMESPACE::ImageLayout finalLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
+
   };
   static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AttachmentDescription>::value, "struct wrapper is not a standard layout!" );
 
   struct AttachmentDescription2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentDescription2;
+
     VULKAN_HPP_CONSTEXPR AttachmentDescription2( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags flags_ = {},
                                                  VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
                                                  VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1,
@@ -23615,6 +24487,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAttachmentDescription2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentDescription2*>( this );
@@ -23625,6 +24498,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentDescription2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AttachmentDescription2 const& ) const = default;
 #else
@@ -23649,6 +24523,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAttachmentDescription2;
     const void* pNext = {};
@@ -23661,12 +24537,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::AttachmentStoreOp stencilStoreOp = VULKAN_HPP_NAMESPACE::AttachmentStoreOp::eStore;
     VULKAN_HPP_NAMESPACE::ImageLayout initialLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
     VULKAN_HPP_NAMESPACE::ImageLayout finalLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
+
   };
   static_assert( sizeof( AttachmentDescription2 ) == sizeof( VkAttachmentDescription2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AttachmentDescription2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eAttachmentDescription2>
+  {
+    using Type = AttachmentDescription2;
+  };
+
   struct AttachmentDescriptionStencilLayout
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentDescriptionStencilLayout;
+
     VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayout( VULKAN_HPP_NAMESPACE::ImageLayout stencilInitialLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined,
                                                              VULKAN_HPP_NAMESPACE::ImageLayout stencilFinalLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
       : stencilInitialLayout( stencilInitialLayout_ )
@@ -23708,6 +24593,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAttachmentDescriptionStencilLayout const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>( this );
@@ -23718,6 +24604,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentDescriptionStencilLayout*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AttachmentDescriptionStencilLayout const& ) const = default;
 #else
@@ -23735,17 +24622,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAttachmentDescriptionStencilLayout;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ImageLayout stencilInitialLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
     VULKAN_HPP_NAMESPACE::ImageLayout stencilFinalLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
+
   };
   static_assert( sizeof( AttachmentDescriptionStencilLayout ) == sizeof( VkAttachmentDescriptionStencilLayout ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AttachmentDescriptionStencilLayout>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eAttachmentDescriptionStencilLayout>
+  {
+    using Type = AttachmentDescriptionStencilLayout;
+  };
+
   struct AttachmentReference
   {
+
     VULKAN_HPP_CONSTEXPR AttachmentReference( uint32_t attachment_ = {},
                                               VULKAN_HPP_NAMESPACE::ImageLayout layout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
       : attachment( attachment_ )
@@ -23775,6 +24672,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAttachmentReference const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentReference*>( this );
@@ -23785,6 +24683,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentReference*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AttachmentReference const& ) const = default;
 #else
@@ -23800,15 +24699,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t attachment = {};
     VULKAN_HPP_NAMESPACE::ImageLayout layout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
+
   };
   static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AttachmentReference>::value, "struct wrapper is not a standard layout!" );
 
   struct AttachmentReference2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentReference2;
+
     VULKAN_HPP_CONSTEXPR AttachmentReference2( uint32_t attachment_ = {},
                                                VULKAN_HPP_NAMESPACE::ImageLayout layout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined,
                                                VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -23858,6 +24762,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAttachmentReference2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentReference2*>( this );
@@ -23868,6 +24773,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentReference2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AttachmentReference2 const& ) const = default;
 #else
@@ -23886,18 +24792,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAttachmentReference2;
     const void* pNext = {};
     uint32_t attachment = {};
     VULKAN_HPP_NAMESPACE::ImageLayout layout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
     VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {};
+
   };
   static_assert( sizeof( AttachmentReference2 ) == sizeof( VkAttachmentReference2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AttachmentReference2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eAttachmentReference2>
+  {
+    using Type = AttachmentReference2;
+  };
+
   struct AttachmentReferenceStencilLayout
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentReferenceStencilLayout;
+
     VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayout( VULKAN_HPP_NAMESPACE::ImageLayout stencilLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
       : stencilLayout( stencilLayout_ )
     {}
@@ -23931,6 +24848,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkAttachmentReferenceStencilLayout const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentReferenceStencilLayout*>( this );
@@ -23941,6 +24859,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentReferenceStencilLayout*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AttachmentReferenceStencilLayout const& ) const = default;
 #else
@@ -23957,16 +24876,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAttachmentReferenceStencilLayout;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ImageLayout stencilLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
+
   };
   static_assert( sizeof( AttachmentReferenceStencilLayout ) == sizeof( VkAttachmentReferenceStencilLayout ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AttachmentReferenceStencilLayout>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eAttachmentReferenceStencilLayout>
+  {
+    using Type = AttachmentReferenceStencilLayout;
+  };
+
   struct Extent2D
   {
+
     VULKAN_HPP_CONSTEXPR Extent2D( uint32_t width_ = {},
                                    uint32_t height_ = {} ) VULKAN_HPP_NOEXCEPT
       : width( width_ )
@@ -23996,6 +24925,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExtent2D const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExtent2D*>( this );
@@ -24006,6 +24936,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExtent2D*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( Extent2D const& ) const = default;
 #else
@@ -24021,15 +24952,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t width = {};
     uint32_t height = {};
+
   };
   static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Extent2D>::value, "struct wrapper is not a standard layout!" );
 
   struct SampleLocationEXT
   {
+
     VULKAN_HPP_CONSTEXPR SampleLocationEXT( float x_ = {},
                                             float y_ = {} ) VULKAN_HPP_NOEXCEPT
       : x( x_ )
@@ -24059,6 +24994,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSampleLocationEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSampleLocationEXT*>( this );
@@ -24069,6 +25005,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSampleLocationEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SampleLocationEXT const& ) const = default;
 #else
@@ -24084,15 +25021,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     float x = {};
     float y = {};
+
   };
   static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SampleLocationEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct SampleLocationsInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSampleLocationsInfoEXT;
+
     VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits sampleLocationsPerPixel_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1,
                                                  VULKAN_HPP_NAMESPACE::Extent2D sampleLocationGridSize_ = {},
                                                  uint32_t sampleLocationsCount_ = {},
@@ -24132,7 +25074,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SampleLocationsInfoEXT & setSampleLocationGridSize( VULKAN_HPP_NAMESPACE::Extent2D sampleLocationGridSize_ ) VULKAN_HPP_NOEXCEPT
+    SampleLocationsInfoEXT & setSampleLocationGridSize( VULKAN_HPP_NAMESPACE::Extent2D const & sampleLocationGridSize_ ) VULKAN_HPP_NOEXCEPT
     {
       sampleLocationGridSize = sampleLocationGridSize_;
       return *this;
@@ -24150,6 +25092,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSampleLocationsInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSampleLocationsInfoEXT*>( this );
@@ -24160,6 +25103,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSampleLocationsInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SampleLocationsInfoEXT const& ) const = default;
 #else
@@ -24179,6 +25123,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSampleLocationsInfoEXT;
     const void* pNext = {};
@@ -24186,12 +25132,20 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Extent2D sampleLocationGridSize = {};
     uint32_t sampleLocationsCount = {};
     const VULKAN_HPP_NAMESPACE::SampleLocationEXT* pSampleLocations = {};
+
   };
   static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SampleLocationsInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSampleLocationsInfoEXT>
+  {
+    using Type = SampleLocationsInfoEXT;
+  };
+
   struct AttachmentSampleLocationsEXT
   {
+
     VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = {},
                                                        VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT
       : attachmentIndex( attachmentIndex_ )
@@ -24215,12 +25169,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AttachmentSampleLocationsEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT
+    AttachmentSampleLocationsEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT
     {
       sampleLocationsInfo = sampleLocationsInfo_;
       return *this;
     }
 
+
     operator VkAttachmentSampleLocationsEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkAttachmentSampleLocationsEXT*>( this );
@@ -24231,6 +25186,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentSampleLocationsEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( AttachmentSampleLocationsEXT const& ) const = default;
 #else
@@ -24246,15 +25202,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t attachmentIndex = {};
     VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo = {};
+
   };
   static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AttachmentSampleLocationsEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct BaseInStructure
   {
+
     BaseInStructure() VULKAN_HPP_NOEXCEPT
     {}
 
@@ -24275,6 +25235,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBaseInStructure const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBaseInStructure*>( this );
@@ -24285,6 +25246,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBaseInStructure*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BaseInStructure const& ) const = default;
 #else
@@ -24300,15 +25262,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType = {};
     const struct VULKAN_HPP_NAMESPACE::BaseInStructure* pNext = {};
+
   };
   static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BaseInStructure>::value, "struct wrapper is not a standard layout!" );
 
   struct BaseOutStructure
   {
+
     BaseOutStructure() VULKAN_HPP_NOEXCEPT
     {}
 
@@ -24329,6 +25295,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBaseOutStructure const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBaseOutStructure*>( this );
@@ -24339,6 +25306,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBaseOutStructure*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BaseOutStructure const& ) const = default;
 #else
@@ -24354,15 +25322,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType = {};
     struct VULKAN_HPP_NAMESPACE::BaseOutStructure* pNext = {};
+
   };
   static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BaseOutStructure>::value, "struct wrapper is not a standard layout!" );
 
   struct BindAccelerationStructureMemoryInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindAccelerationStructureMemoryInfoKHR;
+
     VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure_ = {},
                                                                  VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {},
                                                                  VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset_ = {},
@@ -24428,6 +25401,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBindAccelerationStructureMemoryInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindAccelerationStructureMemoryInfoKHR*>( this );
@@ -24438,6 +25412,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BindAccelerationStructureMemoryInfoKHR const& ) const = default;
 #else
@@ -24458,6 +25433,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoKHR;
     const void* pNext = {};
@@ -24466,12 +25443,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset = {};
     uint32_t deviceIndexCount = {};
     const uint32_t* pDeviceIndices = {};
+
   };
   static_assert( sizeof( BindAccelerationStructureMemoryInfoKHR ) == sizeof( VkBindAccelerationStructureMemoryInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindAccelerationStructureMemoryInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBindAccelerationStructureMemoryInfoKHR>
+  {
+    using Type = BindAccelerationStructureMemoryInfoKHR;
+  };
+
   struct BindBufferMemoryDeviceGroupInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindBufferMemoryDeviceGroupInfo;
+
     VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = {},
                                                           const uint32_t* pDeviceIndices_ = {} ) VULKAN_HPP_NOEXCEPT
       : deviceIndexCount( deviceIndexCount_ )
@@ -24513,6 +25499,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBindBufferMemoryDeviceGroupInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>( this );
@@ -24523,6 +25510,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BindBufferMemoryDeviceGroupInfo const& ) const = default;
 #else
@@ -24540,17 +25528,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo;
     const void* pNext = {};
     uint32_t deviceIndexCount = {};
     const uint32_t* pDeviceIndices = {};
+
   };
   static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindBufferMemoryDeviceGroupInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBindBufferMemoryDeviceGroupInfo>
+  {
+    using Type = BindBufferMemoryDeviceGroupInfo;
+  };
+
   struct BindBufferMemoryInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindBufferMemoryInfo;
+
     VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {},
                                                VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {},
                                                VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -24600,6 +25599,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBindBufferMemoryInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindBufferMemoryInfo*>( this );
@@ -24610,6 +25610,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindBufferMemoryInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BindBufferMemoryInfo const& ) const = default;
 #else
@@ -24628,18 +25629,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindBufferMemoryInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Buffer buffer = {};
     VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
     VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset = {};
+
   };
   static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindBufferMemoryInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBindBufferMemoryInfo>
+  {
+    using Type = BindBufferMemoryInfo;
+  };
+
   struct Offset2D
   {
+
     VULKAN_HPP_CONSTEXPR Offset2D( int32_t x_ = {},
                                    int32_t y_ = {} ) VULKAN_HPP_NOEXCEPT
       : x( x_ )
@@ -24669,6 +25680,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkOffset2D const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkOffset2D*>( this );
@@ -24679,6 +25691,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkOffset2D*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( Offset2D const& ) const = default;
 #else
@@ -24694,15 +25707,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     int32_t x = {};
     int32_t y = {};
+
   };
   static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Offset2D>::value, "struct wrapper is not a standard layout!" );
 
   struct Rect2D
   {
+
     VULKAN_HPP_CONSTEXPR Rect2D( VULKAN_HPP_NAMESPACE::Offset2D offset_ = {},
                                  VULKAN_HPP_NAMESPACE::Extent2D extent_ = {} ) VULKAN_HPP_NOEXCEPT
       : offset( offset_ )
@@ -24720,18 +25737,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    Rect2D & setOffset( VULKAN_HPP_NAMESPACE::Offset2D offset_ ) VULKAN_HPP_NOEXCEPT
+    Rect2D & setOffset( VULKAN_HPP_NAMESPACE::Offset2D const & offset_ ) VULKAN_HPP_NOEXCEPT
     {
       offset = offset_;
       return *this;
     }
 
-    Rect2D & setExtent( VULKAN_HPP_NAMESPACE::Extent2D extent_ ) VULKAN_HPP_NOEXCEPT
+    Rect2D & setExtent( VULKAN_HPP_NAMESPACE::Extent2D const & extent_ ) VULKAN_HPP_NOEXCEPT
     {
       extent = extent_;
       return *this;
     }
 
+
     operator VkRect2D const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRect2D*>( this );
@@ -24742,6 +25760,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRect2D*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( Rect2D const& ) const = default;
 #else
@@ -24757,15 +25776,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Offset2D offset = {};
     VULKAN_HPP_NAMESPACE::Extent2D extent = {};
+
   };
   static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Rect2D>::value, "struct wrapper is not a standard layout!" );
 
   struct BindImageMemoryDeviceGroupInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemoryDeviceGroupInfo;
+
     VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = {},
                                                          const uint32_t* pDeviceIndices_ = {},
                                                          uint32_t splitInstanceBindRegionCount_ = {},
@@ -24823,6 +25847,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBindImageMemoryDeviceGroupInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>( this );
@@ -24833,6 +25858,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BindImageMemoryDeviceGroupInfo const& ) const = default;
 #else
@@ -24852,6 +25878,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo;
     const void* pNext = {};
@@ -24859,12 +25887,21 @@ namespace VULKAN_HPP_NAMESPACE
     const uint32_t* pDeviceIndices = {};
     uint32_t splitInstanceBindRegionCount = {};
     const VULKAN_HPP_NAMESPACE::Rect2D* pSplitInstanceBindRegions = {};
+
   };
   static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindImageMemoryDeviceGroupInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBindImageMemoryDeviceGroupInfo>
+  {
+    using Type = BindImageMemoryDeviceGroupInfo;
+  };
+
   struct BindImageMemoryInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemoryInfo;
+
     VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( VULKAN_HPP_NAMESPACE::Image image_ = {},
                                               VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {},
                                               VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -24914,6 +25951,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBindImageMemoryInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindImageMemoryInfo*>( this );
@@ -24924,6 +25962,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindImageMemoryInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BindImageMemoryInfo const& ) const = default;
 #else
@@ -24942,18 +25981,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindImageMemoryInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Image image = {};
     VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
     VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset = {};
+
   };
   static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindImageMemoryInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBindImageMemoryInfo>
+  {
+    using Type = BindImageMemoryInfo;
+  };
+
   struct BindImageMemorySwapchainInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemorySwapchainInfoKHR;
+
     VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain_ = {},
                                                           uint32_t imageIndex_ = {} ) VULKAN_HPP_NOEXCEPT
       : swapchain( swapchain_ )
@@ -24995,6 +26045,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBindImageMemorySwapchainInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>( this );
@@ -25005,6 +26056,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BindImageMemorySwapchainInfoKHR const& ) const = default;
 #else
@@ -25022,17 +26074,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain = {};
     uint32_t imageIndex = {};
+
   };
   static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindImageMemorySwapchainInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBindImageMemorySwapchainInfoKHR>
+  {
+    using Type = BindImageMemorySwapchainInfoKHR;
+  };
+
   struct BindImagePlaneMemoryInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImagePlaneMemoryInfo;
+
     VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( VULKAN_HPP_NAMESPACE::ImageAspectFlagBits planeAspect_ = VULKAN_HPP_NAMESPACE::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT
       : planeAspect( planeAspect_ )
     {}
@@ -25066,6 +26129,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBindImagePlaneMemoryInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindImagePlaneMemoryInfo*>( this );
@@ -25076,6 +26140,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindImagePlaneMemoryInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BindImagePlaneMemoryInfo const& ) const = default;
 #else
@@ -25092,16 +26157,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindImagePlaneMemoryInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ImageAspectFlagBits planeAspect = VULKAN_HPP_NAMESPACE::ImageAspectFlagBits::eColor;
+
   };
   static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindImagePlaneMemoryInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBindImagePlaneMemoryInfo>
+  {
+    using Type = BindImagePlaneMemoryInfo;
+  };
+
   struct BindIndexBufferIndirectCommandNV
   {
+
     VULKAN_HPP_CONSTEXPR BindIndexBufferIndirectCommandNV( VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress_ = {},
                                                            uint32_t size_ = {},
                                                            VULKAN_HPP_NAMESPACE::IndexType indexType_ = VULKAN_HPP_NAMESPACE::IndexType::eUint16 ) VULKAN_HPP_NOEXCEPT
@@ -25139,6 +26214,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBindIndexBufferIndirectCommandNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindIndexBufferIndirectCommandNV*>( this );
@@ -25149,6 +26225,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindIndexBufferIndirectCommandNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BindIndexBufferIndirectCommandNV const& ) const = default;
 #else
@@ -25165,16 +26242,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress = {};
     uint32_t size = {};
     VULKAN_HPP_NAMESPACE::IndexType indexType = VULKAN_HPP_NAMESPACE::IndexType::eUint16;
+
   };
   static_assert( sizeof( BindIndexBufferIndirectCommandNV ) == sizeof( VkBindIndexBufferIndirectCommandNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindIndexBufferIndirectCommandNV>::value, "struct wrapper is not a standard layout!" );
 
   struct BindShaderGroupIndirectCommandNV
   {
+
     VULKAN_HPP_CONSTEXPR BindShaderGroupIndirectCommandNV( uint32_t groupIndex_ = {} ) VULKAN_HPP_NOEXCEPT
       : groupIndex( groupIndex_ )
     {}
@@ -25196,6 +26277,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBindShaderGroupIndirectCommandNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindShaderGroupIndirectCommandNV*>( this );
@@ -25206,6 +26288,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindShaderGroupIndirectCommandNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BindShaderGroupIndirectCommandNV const& ) const = default;
 #else
@@ -25220,14 +26303,18 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t groupIndex = {};
+
   };
   static_assert( sizeof( BindShaderGroupIndirectCommandNV ) == sizeof( VkBindShaderGroupIndirectCommandNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindShaderGroupIndirectCommandNV>::value, "struct wrapper is not a standard layout!" );
 
   struct SparseMemoryBind
   {
+
     VULKAN_HPP_CONSTEXPR SparseMemoryBind( VULKAN_HPP_NAMESPACE::DeviceSize resourceOffset_ = {},
                                            VULKAN_HPP_NAMESPACE::DeviceSize size_ = {},
                                            VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {},
@@ -25281,6 +26368,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSparseMemoryBind const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseMemoryBind*>( this );
@@ -25291,6 +26379,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseMemoryBind*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SparseMemoryBind const& ) const = default;
 #else
@@ -25309,18 +26398,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DeviceSize resourceOffset = {};
     VULKAN_HPP_NAMESPACE::DeviceSize size = {};
     VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
     VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset = {};
     VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags flags = {};
+
   };
   static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SparseMemoryBind>::value, "struct wrapper is not a standard layout!" );
 
   struct SparseBufferMemoryBindInfo
   {
+
     VULKAN_HPP_CONSTEXPR SparseBufferMemoryBindInfo( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {},
                                                      uint32_t bindCount_ = {},
                                                      const VULKAN_HPP_NAMESPACE::SparseMemoryBind* pBinds_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -25358,6 +26451,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSparseBufferMemoryBindInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>( this );
@@ -25368,6 +26462,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseBufferMemoryBindInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SparseBufferMemoryBindInfo const& ) const = default;
 #else
@@ -25384,16 +26479,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Buffer buffer = {};
     uint32_t bindCount = {};
     const VULKAN_HPP_NAMESPACE::SparseMemoryBind* pBinds = {};
+
   };
   static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SparseBufferMemoryBindInfo>::value, "struct wrapper is not a standard layout!" );
 
   struct SparseImageOpaqueMemoryBindInfo
   {
+
     VULKAN_HPP_CONSTEXPR SparseImageOpaqueMemoryBindInfo( VULKAN_HPP_NAMESPACE::Image image_ = {},
                                                           uint32_t bindCount_ = {},
                                                           const VULKAN_HPP_NAMESPACE::SparseMemoryBind* pBinds_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -25431,6 +26530,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSparseImageOpaqueMemoryBindInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>( this );
@@ -25441,6 +26541,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SparseImageOpaqueMemoryBindInfo const& ) const = default;
 #else
@@ -25457,16 +26558,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Image image = {};
     uint32_t bindCount = {};
     const VULKAN_HPP_NAMESPACE::SparseMemoryBind* pBinds = {};
+
   };
   static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SparseImageOpaqueMemoryBindInfo>::value, "struct wrapper is not a standard layout!" );
 
   struct ImageSubresource
   {
+
     VULKAN_HPP_CONSTEXPR ImageSubresource( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {},
                                            uint32_t mipLevel_ = {},
                                            uint32_t arrayLayer_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -25504,6 +26609,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageSubresource const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageSubresource*>( this );
@@ -25514,6 +26620,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageSubresource*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageSubresource const& ) const = default;
 #else
@@ -25530,16 +26637,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {};
     uint32_t mipLevel = {};
     uint32_t arrayLayer = {};
+
   };
   static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageSubresource>::value, "struct wrapper is not a standard layout!" );
 
   struct Offset3D
   {
+
     VULKAN_HPP_CONSTEXPR Offset3D( int32_t x_ = {},
                                    int32_t y_ = {},
                                    int32_t z_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -25584,6 +26695,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkOffset3D const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkOffset3D*>( this );
@@ -25594,6 +26706,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkOffset3D*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( Offset3D const& ) const = default;
 #else
@@ -25610,16 +26723,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     int32_t x = {};
     int32_t y = {};
     int32_t z = {};
+
   };
   static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Offset3D>::value, "struct wrapper is not a standard layout!" );
 
   struct Extent3D
   {
+
     VULKAN_HPP_CONSTEXPR Extent3D( uint32_t width_ = {},
                                    uint32_t height_ = {},
                                    uint32_t depth_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -25664,6 +26781,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExtent3D const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExtent3D*>( this );
@@ -25674,6 +26792,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExtent3D*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( Extent3D const& ) const = default;
 #else
@@ -25690,16 +26809,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t width = {};
     uint32_t height = {};
     uint32_t depth = {};
+
   };
   static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Extent3D>::value, "struct wrapper is not a standard layout!" );
 
   struct SparseImageMemoryBind
   {
+
     VULKAN_HPP_CONSTEXPR SparseImageMemoryBind( VULKAN_HPP_NAMESPACE::ImageSubresource subresource_ = {},
                                                 VULKAN_HPP_NAMESPACE::Offset3D offset_ = {},
                                                 VULKAN_HPP_NAMESPACE::Extent3D extent_ = {},
@@ -25725,19 +26848,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SparseImageMemoryBind & setSubresource( VULKAN_HPP_NAMESPACE::ImageSubresource subresource_ ) VULKAN_HPP_NOEXCEPT
+    SparseImageMemoryBind & setSubresource( VULKAN_HPP_NAMESPACE::ImageSubresource const & subresource_ ) VULKAN_HPP_NOEXCEPT
     {
       subresource = subresource_;
       return *this;
     }
 
-    SparseImageMemoryBind & setOffset( VULKAN_HPP_NAMESPACE::Offset3D offset_ ) VULKAN_HPP_NOEXCEPT
+    SparseImageMemoryBind & setOffset( VULKAN_HPP_NAMESPACE::Offset3D const & offset_ ) VULKAN_HPP_NOEXCEPT
     {
       offset = offset_;
       return *this;
     }
 
-    SparseImageMemoryBind & setExtent( VULKAN_HPP_NAMESPACE::Extent3D extent_ ) VULKAN_HPP_NOEXCEPT
+    SparseImageMemoryBind & setExtent( VULKAN_HPP_NAMESPACE::Extent3D const & extent_ ) VULKAN_HPP_NOEXCEPT
     {
       extent = extent_;
       return *this;
@@ -25761,6 +26884,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSparseImageMemoryBind const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageMemoryBind*>( this );
@@ -25771,6 +26895,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageMemoryBind*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SparseImageMemoryBind const& ) const = default;
 #else
@@ -25790,6 +26915,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ImageSubresource subresource = {};
     VULKAN_HPP_NAMESPACE::Offset3D offset = {};
@@ -25797,12 +26924,14 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
     VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset = {};
     VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags flags = {};
+
   };
   static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SparseImageMemoryBind>::value, "struct wrapper is not a standard layout!" );
 
   struct SparseImageMemoryBindInfo
   {
+
     VULKAN_HPP_CONSTEXPR SparseImageMemoryBindInfo( VULKAN_HPP_NAMESPACE::Image image_ = {},
                                                     uint32_t bindCount_ = {},
                                                     const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind* pBinds_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -25840,6 +26969,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSparseImageMemoryBindInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>( this );
@@ -25850,6 +26980,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageMemoryBindInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SparseImageMemoryBindInfo const& ) const = default;
 #else
@@ -25866,16 +26997,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Image image = {};
     uint32_t bindCount = {};
     const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind* pBinds = {};
+
   };
   static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SparseImageMemoryBindInfo>::value, "struct wrapper is not a standard layout!" );
 
   struct BindSparseInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindSparseInfo;
+
     VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = {},
                                          const VULKAN_HPP_NAMESPACE::Semaphore* pWaitSemaphores_ = {},
                                          uint32_t bufferBindCount_ = {},
@@ -25981,6 +27117,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBindSparseInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindSparseInfo*>( this );
@@ -25991,6 +27128,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindSparseInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BindSparseInfo const& ) const = default;
 #else
@@ -26016,6 +27154,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindSparseInfo;
     const void* pNext = {};
@@ -26029,12 +27169,20 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo* pImageBinds = {};
     uint32_t signalSemaphoreCount = {};
     const VULKAN_HPP_NAMESPACE::Semaphore* pSignalSemaphores = {};
+
   };
   static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindSparseInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBindSparseInfo>
+  {
+    using Type = BindSparseInfo;
+  };
+
   struct BindVertexBufferIndirectCommandNV
   {
+
     VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandNV( VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress_ = {},
                                                             uint32_t size_ = {},
                                                             uint32_t stride_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -26072,6 +27220,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBindVertexBufferIndirectCommandNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBindVertexBufferIndirectCommandNV*>( this );
@@ -26082,6 +27231,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindVertexBufferIndirectCommandNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BindVertexBufferIndirectCommandNV const& ) const = default;
 #else
@@ -26098,16 +27248,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress = {};
     uint32_t size = {};
     uint32_t stride = {};
+
   };
   static_assert( sizeof( BindVertexBufferIndirectCommandNV ) == sizeof( VkBindVertexBufferIndirectCommandNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindVertexBufferIndirectCommandNV>::value, "struct wrapper is not a standard layout!" );
 
   struct BufferCopy
   {
+
     VULKAN_HPP_CONSTEXPR BufferCopy( VULKAN_HPP_NAMESPACE::DeviceSize srcOffset_ = {},
                                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset_ = {},
                                      VULKAN_HPP_NAMESPACE::DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -26145,6 +27299,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBufferCopy const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferCopy*>( this );
@@ -26155,6 +27310,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferCopy*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BufferCopy const& ) const = default;
 #else
@@ -26171,16 +27327,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DeviceSize srcOffset = {};
     VULKAN_HPP_NAMESPACE::DeviceSize dstOffset = {};
     VULKAN_HPP_NAMESPACE::DeviceSize size = {};
+
   };
   static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BufferCopy>::value, "struct wrapper is not a standard layout!" );
 
   struct BufferCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCreateInfo;
+
     VULKAN_HPP_CONSTEXPR BufferCreateInfo( VULKAN_HPP_NAMESPACE::BufferCreateFlags flags_ = {},
                                            VULKAN_HPP_NAMESPACE::DeviceSize size_ = {},
                                            VULKAN_HPP_NAMESPACE::BufferUsageFlags usage_ = {},
@@ -26254,6 +27415,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBufferCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferCreateInfo*>( this );
@@ -26264,6 +27426,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BufferCreateInfo const& ) const = default;
 #else
@@ -26285,6 +27448,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferCreateInfo;
     const void* pNext = {};
@@ -26294,12 +27459,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::SharingMode sharingMode = VULKAN_HPP_NAMESPACE::SharingMode::eExclusive;
     uint32_t queueFamilyIndexCount = {};
     const uint32_t* pQueueFamilyIndices = {};
+
   };
   static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BufferCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBufferCreateInfo>
+  {
+    using Type = BufferCreateInfo;
+  };
+
   struct BufferDeviceAddressCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferDeviceAddressCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ = {} ) VULKAN_HPP_NOEXCEPT
       : deviceAddress( deviceAddress_ )
     {}
@@ -26333,6 +27507,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBufferDeviceAddressCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>( this );
@@ -26343,6 +27518,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BufferDeviceAddressCreateInfoEXT const& ) const = default;
 #else
@@ -26359,16 +27535,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress = {};
+
   };
   static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BufferDeviceAddressCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBufferDeviceAddressCreateInfoEXT>
+  {
+    using Type = BufferDeviceAddressCreateInfoEXT;
+  };
+
   struct BufferDeviceAddressInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferDeviceAddressInfo;
+
     VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfo( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT
       : buffer( buffer_ )
     {}
@@ -26402,6 +27589,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBufferDeviceAddressInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferDeviceAddressInfo*>( this );
@@ -26412,6 +27600,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferDeviceAddressInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BufferDeviceAddressInfo const& ) const = default;
 #else
@@ -26428,16 +27617,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferDeviceAddressInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Buffer buffer = {};
+
   };
   static_assert( sizeof( BufferDeviceAddressInfo ) == sizeof( VkBufferDeviceAddressInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BufferDeviceAddressInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBufferDeviceAddressInfo>
+  {
+    using Type = BufferDeviceAddressInfo;
+  };
+
   struct ImageSubresourceLayers
   {
+
     VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {},
                                                  uint32_t mipLevel_ = {},
                                                  uint32_t baseArrayLayer_ = {},
@@ -26483,6 +27682,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageSubresourceLayers const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageSubresourceLayers*>( this );
@@ -26493,6 +27693,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageSubresourceLayers*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageSubresourceLayers const& ) const = default;
 #else
@@ -26510,17 +27711,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {};
     uint32_t mipLevel = {};
     uint32_t baseArrayLayer = {};
     uint32_t layerCount = {};
+
   };
   static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageSubresourceLayers>::value, "struct wrapper is not a standard layout!" );
 
   struct BufferImageCopy
   {
+
     VULKAN_HPP_CONSTEXPR BufferImageCopy( VULKAN_HPP_NAMESPACE::DeviceSize bufferOffset_ = {},
                                           uint32_t bufferRowLength_ = {},
                                           uint32_t bufferImageHeight_ = {},
@@ -26564,24 +27769,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BufferImageCopy & setImageSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers imageSubresource_ ) VULKAN_HPP_NOEXCEPT
+    BufferImageCopy & setImageSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
       imageSubresource = imageSubresource_;
       return *this;
     }
 
-    BufferImageCopy & setImageOffset( VULKAN_HPP_NAMESPACE::Offset3D imageOffset_ ) VULKAN_HPP_NOEXCEPT
+    BufferImageCopy & setImageOffset( VULKAN_HPP_NAMESPACE::Offset3D const & imageOffset_ ) VULKAN_HPP_NOEXCEPT
     {
       imageOffset = imageOffset_;
       return *this;
     }
 
-    BufferImageCopy & setImageExtent( VULKAN_HPP_NAMESPACE::Extent3D imageExtent_ ) VULKAN_HPP_NOEXCEPT
+    BufferImageCopy & setImageExtent( VULKAN_HPP_NAMESPACE::Extent3D const & imageExtent_ ) VULKAN_HPP_NOEXCEPT
     {
       imageExtent = imageExtent_;
       return *this;
     }
 
+
     operator VkBufferImageCopy const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferImageCopy*>( this );
@@ -26592,6 +27798,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferImageCopy*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BufferImageCopy const& ) const = default;
 #else
@@ -26611,6 +27818,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DeviceSize bufferOffset = {};
     uint32_t bufferRowLength = {};
@@ -26618,12 +27827,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ImageSubresourceLayers imageSubresource = {};
     VULKAN_HPP_NAMESPACE::Offset3D imageOffset = {};
     VULKAN_HPP_NAMESPACE::Extent3D imageExtent = {};
+
   };
   static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BufferImageCopy>::value, "struct wrapper is not a standard layout!" );
 
   struct BufferMemoryBarrier
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryBarrier;
+
     VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ = {},
                                               VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ = {},
                                               uint32_t srcQueueFamilyIndex_ = {},
@@ -26705,6 +27917,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBufferMemoryBarrier const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferMemoryBarrier*>( this );
@@ -26715,6 +27928,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferMemoryBarrier*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BufferMemoryBarrier const& ) const = default;
 #else
@@ -26737,6 +27951,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferMemoryBarrier;
     const void* pNext = {};
@@ -26747,12 +27963,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Buffer buffer = {};
     VULKAN_HPP_NAMESPACE::DeviceSize offset = {};
     VULKAN_HPP_NAMESPACE::DeviceSize size = {};
+
   };
   static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BufferMemoryBarrier>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBufferMemoryBarrier>
+  {
+    using Type = BufferMemoryBarrier;
+  };
+
   struct BufferMemoryRequirementsInfo2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryRequirementsInfo2;
+
     VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT
       : buffer( buffer_ )
     {}
@@ -26786,6 +28011,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBufferMemoryRequirementsInfo2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( this );
@@ -26796,6 +28022,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BufferMemoryRequirementsInfo2 const& ) const = default;
 #else
@@ -26812,16 +28039,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferMemoryRequirementsInfo2;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Buffer buffer = {};
+
   };
   static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BufferMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBufferMemoryRequirementsInfo2>
+  {
+    using Type = BufferMemoryRequirementsInfo2;
+  };
+
   struct BufferOpaqueCaptureAddressCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferOpaqueCaptureAddressCreateInfo;
+
     VULKAN_HPP_CONSTEXPR BufferOpaqueCaptureAddressCreateInfo( uint64_t opaqueCaptureAddress_ = {} ) VULKAN_HPP_NOEXCEPT
       : opaqueCaptureAddress( opaqueCaptureAddress_ )
     {}
@@ -26855,6 +28093,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBufferOpaqueCaptureAddressCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>( this );
@@ -26865,6 +28104,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BufferOpaqueCaptureAddressCreateInfo const& ) const = default;
 #else
@@ -26881,16 +28121,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferOpaqueCaptureAddressCreateInfo;
     const void* pNext = {};
     uint64_t opaqueCaptureAddress = {};
+
   };
   static_assert( sizeof( BufferOpaqueCaptureAddressCreateInfo ) == sizeof( VkBufferOpaqueCaptureAddressCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BufferOpaqueCaptureAddressCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBufferOpaqueCaptureAddressCreateInfo>
+  {
+    using Type = BufferOpaqueCaptureAddressCreateInfo;
+  };
+
   struct BufferViewCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferViewCreateInfo;
+
     VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( VULKAN_HPP_NAMESPACE::BufferViewCreateFlags flags_ = {},
                                                VULKAN_HPP_NAMESPACE::Buffer buffer_ = {},
                                                VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
@@ -26956,6 +28207,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkBufferViewCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkBufferViewCreateInfo*>( this );
@@ -26966,6 +28218,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferViewCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( BufferViewCreateInfo const& ) const = default;
 #else
@@ -26986,6 +28239,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferViewCreateInfo;
     const void* pNext = {};
@@ -26994,12 +28249,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Format format = VULKAN_HPP_NAMESPACE::Format::eUndefined;
     VULKAN_HPP_NAMESPACE::DeviceSize offset = {};
     VULKAN_HPP_NAMESPACE::DeviceSize range = {};
+
   };
   static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BufferViewCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eBufferViewCreateInfo>
+  {
+    using Type = BufferViewCreateInfo;
+  };
+
   struct CalibratedTimestampInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCalibratedTimestampInfoEXT;
+
     VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( VULKAN_HPP_NAMESPACE::TimeDomainEXT timeDomain_ = VULKAN_HPP_NAMESPACE::TimeDomainEXT::eDevice ) VULKAN_HPP_NOEXCEPT
       : timeDomain( timeDomain_ )
     {}
@@ -27033,6 +28297,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCalibratedTimestampInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( this );
@@ -27043,6 +28308,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCalibratedTimestampInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CalibratedTimestampInfoEXT const& ) const = default;
 #else
@@ -27059,16 +28325,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCalibratedTimestampInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::TimeDomainEXT timeDomain = VULKAN_HPP_NAMESPACE::TimeDomainEXT::eDevice;
+
   };
   static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CalibratedTimestampInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eCalibratedTimestampInfoEXT>
+  {
+    using Type = CalibratedTimestampInfoEXT;
+  };
+
   struct CheckpointDataNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCheckpointDataNV;
+
     VULKAN_HPP_CONSTEXPR CheckpointDataNV( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits stage_ = VULKAN_HPP_NAMESPACE::PipelineStageFlagBits::eTopOfPipe,
                                            void* pCheckpointMarker_ = {} ) VULKAN_HPP_NOEXCEPT
       : stage( stage_ )
@@ -27092,6 +28369,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCheckpointDataNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCheckpointDataNV*>( this );
@@ -27102,6 +28380,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCheckpointDataNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CheckpointDataNV const& ) const = default;
 #else
@@ -27119,15 +28398,24 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCheckpointDataNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineStageFlagBits stage = VULKAN_HPP_NAMESPACE::PipelineStageFlagBits::eTopOfPipe;
     void* pCheckpointMarker = {};
+
   };
   static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CheckpointDataNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eCheckpointDataNV>
+  {
+    using Type = CheckpointDataNV;
+  };
+
   union ClearColorValue
   {
     ClearColorValue( VULKAN_HPP_NAMESPACE::ClearColorValue const& rhs ) VULKAN_HPP_NOEXCEPT
@@ -27136,19 +28424,16 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     ClearColorValue( const std::array<float,4>& float32_ = {} )
-    {
-      float32 = float32_;
-    }
+      : float32( float32_ )
+    {}
 
     ClearColorValue( const std::array<int32_t,4>& int32_ )
-    {
-      int32 = int32_;
-    }
+      : int32( int32_ )
+    {}
 
     ClearColorValue( const std::array<uint32_t,4>& uint32_ )
-    {
-      uint32 = uint32_;
-    }
+      : uint32( uint32_ )
+    {}
 
     ClearColorValue & setFloat32( std::array<float,4> float32_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -27191,6 +28476,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ClearDepthStencilValue
   {
+
     VULKAN_HPP_CONSTEXPR ClearDepthStencilValue( float depth_ = {},
                                                  uint32_t stencil_ = {} ) VULKAN_HPP_NOEXCEPT
       : depth( depth_ )
@@ -27220,6 +28506,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkClearDepthStencilValue const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkClearDepthStencilValue*>( this );
@@ -27230,6 +28517,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkClearDepthStencilValue*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ClearDepthStencilValue const& ) const = default;
 #else
@@ -27245,9 +28533,12 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     float depth = {};
     uint32_t stencil = {};
+
   };
   static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ClearDepthStencilValue>::value, "struct wrapper is not a standard layout!" );
@@ -27260,22 +28551,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     ClearValue( VULKAN_HPP_NAMESPACE::ClearColorValue color_ = {} )
-    {
-      color = color_;
-    }
+      : color( color_ )
+    {}
 
     ClearValue( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue depthStencil_ )
-    {
-      depthStencil = depthStencil_;
-    }
+      : depthStencil( depthStencil_ )
+    {}
 
-    ClearValue & setColor( VULKAN_HPP_NAMESPACE::ClearColorValue color_ ) VULKAN_HPP_NOEXCEPT
+    ClearValue & setColor( VULKAN_HPP_NAMESPACE::ClearColorValue const & color_ ) VULKAN_HPP_NOEXCEPT
     {
       color = color_;
       return *this;
     }
 
-    ClearValue & setDepthStencil( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue depthStencil_ ) VULKAN_HPP_NOEXCEPT
+    ClearValue & setDepthStencil( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & depthStencil_ ) VULKAN_HPP_NOEXCEPT
     {
       depthStencil = depthStencil_;
       return *this;
@@ -27308,6 +28597,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ClearAttachment
   {
+
     ClearAttachment( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {},
                      uint32_t colorAttachment_ = {},
                      VULKAN_HPP_NAMESPACE::ClearValue clearValue_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -27339,12 +28629,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ClearAttachment & setClearValue( VULKAN_HPP_NAMESPACE::ClearValue clearValue_ ) VULKAN_HPP_NOEXCEPT
+    ClearAttachment & setClearValue( VULKAN_HPP_NAMESPACE::ClearValue const & clearValue_ ) VULKAN_HPP_NOEXCEPT
     {
       clearValue = clearValue_;
       return *this;
     }
 
+
     operator VkClearAttachment const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkClearAttachment*>( this );
@@ -27355,16 +28646,21 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkClearAttachment*>( this );
     }
 
+
+
+
   public:
     VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {};
     uint32_t colorAttachment = {};
     VULKAN_HPP_NAMESPACE::ClearValue clearValue = {};
+
   };
   static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ClearAttachment>::value, "struct wrapper is not a standard layout!" );
 
   struct ClearRect
   {
+
     VULKAN_HPP_CONSTEXPR ClearRect( VULKAN_HPP_NAMESPACE::Rect2D rect_ = {},
                                     uint32_t baseArrayLayer_ = {},
                                     uint32_t layerCount_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -27384,7 +28680,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ClearRect & setRect( VULKAN_HPP_NAMESPACE::Rect2D rect_ ) VULKAN_HPP_NOEXCEPT
+    ClearRect & setRect( VULKAN_HPP_NAMESPACE::Rect2D const & rect_ ) VULKAN_HPP_NOEXCEPT
     {
       rect = rect_;
       return *this;
@@ -27402,6 +28698,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkClearRect const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkClearRect*>( this );
@@ -27412,6 +28709,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkClearRect*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ClearRect const& ) const = default;
 #else
@@ -27428,16 +28726,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Rect2D rect = {};
     uint32_t baseArrayLayer = {};
     uint32_t layerCount = {};
+
   };
   static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ClearRect>::value, "struct wrapper is not a standard layout!" );
 
   struct CoarseSampleLocationNV
   {
+
     VULKAN_HPP_CONSTEXPR CoarseSampleLocationNV( uint32_t pixelX_ = {},
                                                  uint32_t pixelY_ = {},
                                                  uint32_t sample_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -27475,6 +28777,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCoarseSampleLocationNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCoarseSampleLocationNV*>( this );
@@ -27485,6 +28788,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCoarseSampleLocationNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CoarseSampleLocationNV const& ) const = default;
 #else
@@ -27501,16 +28805,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t pixelX = {};
     uint32_t pixelY = {};
     uint32_t sample = {};
+
   };
   static_assert( sizeof( CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CoarseSampleLocationNV>::value, "struct wrapper is not a standard layout!" );
 
   struct CoarseSampleOrderCustomNV
   {
+
     VULKAN_HPP_CONSTEXPR CoarseSampleOrderCustomNV( VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV shadingRate_ = VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV::eNoInvocations,
                                                     uint32_t sampleCount_ = {},
                                                     uint32_t sampleLocationCount_ = {},
@@ -27556,6 +28864,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCoarseSampleOrderCustomNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( this );
@@ -27566,6 +28875,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCoarseSampleOrderCustomNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CoarseSampleOrderCustomNV const& ) const = default;
 #else
@@ -27583,17 +28893,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV shadingRate = VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV::eNoInvocations;
     uint32_t sampleCount = {};
     uint32_t sampleLocationCount = {};
     const VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV* pSampleLocations = {};
+
   };
   static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CoarseSampleOrderCustomNV>::value, "struct wrapper is not a standard layout!" );
 
   struct CommandBufferAllocateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferAllocateInfo;
+
     VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( VULKAN_HPP_NAMESPACE::CommandPool commandPool_ = {},
                                                     VULKAN_HPP_NAMESPACE::CommandBufferLevel level_ = VULKAN_HPP_NAMESPACE::CommandBufferLevel::ePrimary,
                                                     uint32_t commandBufferCount_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -27643,6 +28958,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCommandBufferAllocateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferAllocateInfo*>( this );
@@ -27653,6 +28969,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferAllocateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CommandBufferAllocateInfo const& ) const = default;
 #else
@@ -27671,18 +28988,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandBufferAllocateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::CommandPool commandPool = {};
     VULKAN_HPP_NAMESPACE::CommandBufferLevel level = VULKAN_HPP_NAMESPACE::CommandBufferLevel::ePrimary;
     uint32_t commandBufferCount = {};
+
   };
   static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CommandBufferAllocateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eCommandBufferAllocateInfo>
+  {
+    using Type = CommandBufferAllocateInfo;
+  };
+
   struct CommandBufferInheritanceInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceInfo;
+
     VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( VULKAN_HPP_NAMESPACE::RenderPass renderPass_ = {},
                                                        uint32_t subpass_ = {},
                                                        VULKAN_HPP_NAMESPACE::Framebuffer framebuffer_ = {},
@@ -27756,6 +29084,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCommandBufferInheritanceInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>( this );
@@ -27766,6 +29095,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferInheritanceInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CommandBufferInheritanceInfo const& ) const = default;
 #else
@@ -27787,6 +29117,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandBufferInheritanceInfo;
     const void* pNext = {};
@@ -27796,12 +29128,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 occlusionQueryEnable = {};
     VULKAN_HPP_NAMESPACE::QueryControlFlags queryFlags = {};
     VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags pipelineStatistics = {};
+
   };
   static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CommandBufferInheritanceInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eCommandBufferInheritanceInfo>
+  {
+    using Type = CommandBufferInheritanceInfo;
+  };
+
   struct CommandBufferBeginInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferBeginInfo;
+
     VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags flags_ = {},
                                                  const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo* pInheritanceInfo_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -27843,6 +29184,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCommandBufferBeginInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferBeginInfo*>( this );
@@ -27853,6 +29195,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferBeginInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CommandBufferBeginInfo const& ) const = default;
 #else
@@ -27870,17 +29213,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandBufferBeginInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags flags = {};
     const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo* pInheritanceInfo = {};
+
   };
   static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CommandBufferBeginInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eCommandBufferBeginInfo>
+  {
+    using Type = CommandBufferBeginInfo;
+  };
+
   struct CommandBufferInheritanceConditionalRenderingInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT;
+
     VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 conditionalRenderingEnable_ = {} ) VULKAN_HPP_NOEXCEPT
       : conditionalRenderingEnable( conditionalRenderingEnable_ )
     {}
@@ -27914,6 +29268,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>( this );
@@ -27924,6 +29279,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CommandBufferInheritanceConditionalRenderingInfoEXT const& ) const = default;
 #else
@@ -27940,16 +29296,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 conditionalRenderingEnable = {};
+
   };
   static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CommandBufferInheritanceConditionalRenderingInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT>
+  {
+    using Type = CommandBufferInheritanceConditionalRenderingInfoEXT;
+  };
+
   struct CommandBufferInheritanceRenderPassTransformInfoQCOM
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM;
+
     VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderPassTransformInfoQCOM( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform_ = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity,
                                                                               VULKAN_HPP_NAMESPACE::Rect2D renderArea_ = {} ) VULKAN_HPP_NOEXCEPT
       : transform( transform_ )
@@ -27985,12 +29352,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CommandBufferInheritanceRenderPassTransformInfoQCOM & setRenderArea( VULKAN_HPP_NAMESPACE::Rect2D renderArea_ ) VULKAN_HPP_NOEXCEPT
+    CommandBufferInheritanceRenderPassTransformInfoQCOM & setRenderArea( VULKAN_HPP_NAMESPACE::Rect2D const & renderArea_ ) VULKAN_HPP_NOEXCEPT
     {
       renderArea = renderArea_;
       return *this;
     }
 
+
     operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>( this );
@@ -28001,6 +29369,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CommandBufferInheritanceRenderPassTransformInfoQCOM const& ) const = default;
 #else
@@ -28018,17 +29387,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity;
     VULKAN_HPP_NAMESPACE::Rect2D renderArea = {};
+
   };
   static_assert( sizeof( CommandBufferInheritanceRenderPassTransformInfoQCOM ) == sizeof( VkCommandBufferInheritanceRenderPassTransformInfoQCOM ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CommandBufferInheritanceRenderPassTransformInfoQCOM>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM>
+  {
+    using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM;
+  };
+
   struct CommandPoolCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandPoolCreateInfo;
+
     VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags flags_ = {},
                                                 uint32_t queueFamilyIndex_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -28070,6 +29450,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCommandPoolCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCommandPoolCreateInfo*>( this );
@@ -28080,6 +29461,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandPoolCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CommandPoolCreateInfo const& ) const = default;
 #else
@@ -28097,17 +29479,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandPoolCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags flags = {};
     uint32_t queueFamilyIndex = {};
+
   };
   static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CommandPoolCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eCommandPoolCreateInfo>
+  {
+    using Type = CommandPoolCreateInfo;
+  };
+
   struct SpecializationMapEntry
   {
+
     VULKAN_HPP_CONSTEXPR SpecializationMapEntry( uint32_t constantID_ = {},
                                                  uint32_t offset_ = {},
                                                  size_t size_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -28145,6 +29537,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSpecializationMapEntry const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSpecializationMapEntry*>( this );
@@ -28155,6 +29548,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSpecializationMapEntry*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SpecializationMapEntry const& ) const = default;
 #else
@@ -28171,16 +29565,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t constantID = {};
     uint32_t offset = {};
     size_t size = {};
+
   };
   static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SpecializationMapEntry>::value, "struct wrapper is not a standard layout!" );
 
   struct SpecializationInfo
   {
+
     VULKAN_HPP_CONSTEXPR SpecializationInfo( uint32_t mapEntryCount_ = {},
                                              const VULKAN_HPP_NAMESPACE::SpecializationMapEntry* pMapEntries_ = {},
                                              size_t dataSize_ = {},
@@ -28226,6 +29624,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSpecializationInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSpecializationInfo*>( this );
@@ -28236,6 +29635,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSpecializationInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SpecializationInfo const& ) const = default;
 #else
@@ -28253,17 +29653,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t mapEntryCount = {};
     const VULKAN_HPP_NAMESPACE::SpecializationMapEntry* pMapEntries = {};
     size_t dataSize = {};
     const void* pData = {};
+
   };
   static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SpecializationInfo>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineShaderStageCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags flags_ = {},
                                                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits stage_ = VULKAN_HPP_NAMESPACE::ShaderStageFlagBits::eVertex,
                                                         VULKAN_HPP_NAMESPACE::ShaderModule module_ = {},
@@ -28329,6 +29734,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineShaderStageCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>( this );
@@ -28339,6 +29745,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineShaderStageCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineShaderStageCreateInfo const& ) const = default;
 #else
@@ -28359,6 +29766,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
     const void* pNext = {};
@@ -28367,12 +29776,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ShaderModule module = {};
     const char* pName = {};
     const VULKAN_HPP_NAMESPACE::SpecializationInfo* pSpecializationInfo = {};
+
   };
   static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineShaderStageCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineShaderStageCreateInfo>
+  {
+    using Type = PipelineShaderStageCreateInfo;
+  };
+
   struct ComputePipelineCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eComputePipelineCreateInfo;
+
     VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {},
                                                     VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo stage_ = {},
                                                     VULKAN_HPP_NAMESPACE::PipelineLayout layout_ = {},
@@ -28414,7 +29832,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ComputePipelineCreateInfo & setStage( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo stage_ ) VULKAN_HPP_NOEXCEPT
+    ComputePipelineCreateInfo & setStage( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & stage_ ) VULKAN_HPP_NOEXCEPT
     {
       stage = stage_;
       return *this;
@@ -28438,6 +29856,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkComputePipelineCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkComputePipelineCreateInfo*>( this );
@@ -28448,6 +29867,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkComputePipelineCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ComputePipelineCreateInfo const& ) const = default;
 #else
@@ -28468,6 +29888,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eComputePipelineCreateInfo;
     const void* pNext = {};
@@ -28476,12 +29898,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::PipelineLayout layout = {};
     VULKAN_HPP_NAMESPACE::Pipeline basePipelineHandle = {};
     int32_t basePipelineIndex = {};
+
   };
   static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ComputePipelineCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eComputePipelineCreateInfo>
+  {
+    using Type = ComputePipelineCreateInfo;
+  };
+
   struct ConditionalRenderingBeginInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eConditionalRenderingBeginInfoEXT;
+
     VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {},
                                                            VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {},
                                                            VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT flags_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -28531,6 +29962,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkConditionalRenderingBeginInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>( this );
@@ -28541,6 +29973,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ConditionalRenderingBeginInfoEXT const& ) const = default;
 #else
@@ -28559,18 +29992,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Buffer buffer = {};
     VULKAN_HPP_NAMESPACE::DeviceSize offset = {};
     VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT flags = {};
+
   };
   static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ConditionalRenderingBeginInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eConditionalRenderingBeginInfoEXT>
+  {
+    using Type = ConditionalRenderingBeginInfoEXT;
+  };
+
   struct ConformanceVersion
   {
+
     VULKAN_HPP_CONSTEXPR ConformanceVersion( uint8_t major_ = {},
                                              uint8_t minor_ = {},
                                              uint8_t subminor_ = {},
@@ -28616,6 +30059,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkConformanceVersion const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkConformanceVersion*>( this );
@@ -28626,6 +30070,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkConformanceVersion*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ConformanceVersion const& ) const = default;
 #else
@@ -28643,17 +30088,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint8_t major = {};
     uint8_t minor = {};
     uint8_t subminor = {};
     uint8_t patch = {};
+
   };
   static_assert( sizeof( ConformanceVersion ) == sizeof( VkConformanceVersion ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ConformanceVersion>::value, "struct wrapper is not a standard layout!" );
 
   struct CooperativeMatrixPropertiesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCooperativeMatrixPropertiesNV;
+
     VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = {},
                                                         uint32_t NSize_ = {},
                                                         uint32_t KSize_ = {},
@@ -28743,6 +30193,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCooperativeMatrixPropertiesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCooperativeMatrixPropertiesNV*>( this );
@@ -28753,6 +30204,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCooperativeMatrixPropertiesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CooperativeMatrixPropertiesNV const& ) const = default;
 #else
@@ -28776,6 +30228,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCooperativeMatrixPropertiesNV;
     void* pNext = {};
@@ -28787,13 +30241,22 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ComponentTypeNV CType = VULKAN_HPP_NAMESPACE::ComponentTypeNV::eFloat16;
     VULKAN_HPP_NAMESPACE::ComponentTypeNV DType = VULKAN_HPP_NAMESPACE::ComponentTypeNV::eFloat16;
     VULKAN_HPP_NAMESPACE::ScopeNV scope = VULKAN_HPP_NAMESPACE::ScopeNV::eDevice;
+
   };
   static_assert( sizeof( CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CooperativeMatrixPropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eCooperativeMatrixPropertiesNV>
+  {
+    using Type = CooperativeMatrixPropertiesNV;
+  };
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct CopyAccelerationStructureInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyAccelerationStructureInfoKHR;
+
     VULKAN_HPP_CONSTEXPR CopyAccelerationStructureInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR src_ = {},
                                                            VULKAN_HPP_NAMESPACE::AccelerationStructureKHR dst_ = {},
                                                            VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode_ = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone ) VULKAN_HPP_NOEXCEPT
@@ -28843,6 +30306,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCopyAccelerationStructureInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyAccelerationStructureInfoKHR*>( this );
@@ -28853,6 +30317,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyAccelerationStructureInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CopyAccelerationStructureInfoKHR const& ) const = default;
 #else
@@ -28871,20 +30336,31 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyAccelerationStructureInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::AccelerationStructureKHR src = {};
     VULKAN_HPP_NAMESPACE::AccelerationStructureKHR dst = {};
     VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone;
+
   };
   static_assert( sizeof( CopyAccelerationStructureInfoKHR ) == sizeof( VkCopyAccelerationStructureInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CopyAccelerationStructureInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eCopyAccelerationStructureInfoKHR>
+  {
+    using Type = CopyAccelerationStructureInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct CopyAccelerationStructureToMemoryInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR;
+
     CopyAccelerationStructureToMemoryInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR src_ = {},
                                               VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR dst_ = {},
                                               VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode_ = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone ) VULKAN_HPP_NOEXCEPT
@@ -28922,7 +30398,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CopyAccelerationStructureToMemoryInfoKHR & setDst( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR dst_ ) VULKAN_HPP_NOEXCEPT
+    CopyAccelerationStructureToMemoryInfoKHR & setDst( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const & dst_ ) VULKAN_HPP_NOEXCEPT
     {
       dst = dst_;
       return *this;
@@ -28934,6 +30410,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCopyAccelerationStructureToMemoryInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR*>( this );
@@ -28944,19 +30421,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR*>( this );
     }
 
+
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::AccelerationStructureKHR src = {};
     VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR dst = {};
     VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone;
+
   };
   static_assert( sizeof( CopyAccelerationStructureToMemoryInfoKHR ) == sizeof( VkCopyAccelerationStructureToMemoryInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CopyAccelerationStructureToMemoryInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eCopyAccelerationStructureToMemoryInfoKHR>
+  {
+    using Type = CopyAccelerationStructureToMemoryInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct CopyDescriptorSet
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyDescriptorSet;
+
     VULKAN_HPP_CONSTEXPR CopyDescriptorSet( VULKAN_HPP_NAMESPACE::DescriptorSet srcSet_ = {},
                                             uint32_t srcBinding_ = {},
                                             uint32_t srcArrayElement_ = {},
@@ -29038,6 +30527,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCopyDescriptorSet const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyDescriptorSet*>( this );
@@ -29048,6 +30538,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyDescriptorSet*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( CopyDescriptorSet const& ) const = default;
 #else
@@ -29070,6 +30561,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyDescriptorSet;
     const void* pNext = {};
@@ -29080,13 +30573,22 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t dstBinding = {};
     uint32_t dstArrayElement = {};
     uint32_t descriptorCount = {};
+
   };
   static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CopyDescriptorSet>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eCopyDescriptorSet>
+  {
+    using Type = CopyDescriptorSet;
+  };
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct CopyMemoryToAccelerationStructureInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR;
+
     CopyMemoryToAccelerationStructureInfoKHR( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR src_ = {},
                                               VULKAN_HPP_NAMESPACE::AccelerationStructureKHR dst_ = {},
                                               VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode_ = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone ) VULKAN_HPP_NOEXCEPT
@@ -29118,7 +30620,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CopyMemoryToAccelerationStructureInfoKHR & setSrc( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR src_ ) VULKAN_HPP_NOEXCEPT
+    CopyMemoryToAccelerationStructureInfoKHR & setSrc( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & src_ ) VULKAN_HPP_NOEXCEPT
     {
       src = src_;
       return *this;
@@ -29136,6 +30638,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkCopyMemoryToAccelerationStructureInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR*>( this );
@@ -29146,20 +30649,32 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR*>( this );
     }
 
+
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR src = {};
     VULKAN_HPP_NAMESPACE::AccelerationStructureKHR dst = {};
     VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone;
+
   };
   static_assert( sizeof( CopyMemoryToAccelerationStructureInfoKHR ) == sizeof( VkCopyMemoryToAccelerationStructureInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CopyMemoryToAccelerationStructureInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eCopyMemoryToAccelerationStructureInfoKHR>
+  {
+    using Type = CopyMemoryToAccelerationStructureInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct D3D12FenceSubmitInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eD3D12FenceSubmitInfoKHR;
+
     VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = {},
                                                   const uint64_t* pWaitSemaphoreValues_ = {},
                                                   uint32_t signalSemaphoreValuesCount_ = {},
@@ -29217,6 +30732,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkD3D12FenceSubmitInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>( this );
@@ -29227,6 +30743,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( D3D12FenceSubmitInfoKHR const& ) const = default;
 #else
@@ -29246,6 +30763,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR;
     const void* pNext = {};
@@ -29253,13 +30772,22 @@ namespace VULKAN_HPP_NAMESPACE
     const uint64_t* pWaitSemaphoreValues = {};
     uint32_t signalSemaphoreValuesCount = {};
     const uint64_t* pSignalSemaphoreValues = {};
+
   };
   static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<D3D12FenceSubmitInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eD3D12FenceSubmitInfoKHR>
+  {
+    using Type = D3D12FenceSubmitInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct DebugMarkerMarkerInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerMarkerInfoEXT;
+
     VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = {},
                                                       std::array<float,4> const& color_ = {} ) VULKAN_HPP_NOEXCEPT
       : pMarkerName( pMarkerName_ )
@@ -29301,6 +30829,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDebugMarkerMarkerInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( this );
@@ -29311,6 +30840,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DebugMarkerMarkerInfoEXT const& ) const = default;
 #else
@@ -29328,17 +30858,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
     const void* pNext = {};
     const char* pMarkerName = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> color = {};
+
   };
   static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugMarkerMarkerInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDebugMarkerMarkerInfoEXT>
+  {
+    using Type = DebugMarkerMarkerInfoEXT;
+  };
+
   struct DebugMarkerObjectNameInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerObjectNameInfoEXT;
+
     VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_ = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown,
                                                        uint64_t object_ = {},
                                                        const char* pObjectName_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -29388,6 +30929,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDebugMarkerObjectNameInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( this );
@@ -29398,6 +30940,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DebugMarkerObjectNameInfoEXT const& ) const = default;
 #else
@@ -29416,18 +30959,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
     uint64_t object = {};
     const char* pObjectName = {};
+
   };
   static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugMarkerObjectNameInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDebugMarkerObjectNameInfoEXT>
+  {
+    using Type = DebugMarkerObjectNameInfoEXT;
+  };
+
   struct DebugMarkerObjectTagInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerObjectTagInfoEXT;
+
     VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_ = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown,
                                                       uint64_t object_ = {},
                                                       uint64_t tagName_ = {},
@@ -29493,6 +31047,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDebugMarkerObjectTagInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( this );
@@ -29503,6 +31058,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DebugMarkerObjectTagInfoEXT const& ) const = default;
 #else
@@ -29523,6 +31079,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
     const void* pNext = {};
@@ -29531,12 +31089,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint64_t tagName = {};
     size_t tagSize = {};
     const void* pTag = {};
+
   };
   static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugMarkerObjectTagInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDebugMarkerObjectTagInfoEXT>
+  {
+    using Type = DebugMarkerObjectTagInfoEXT;
+  };
+
   struct DebugReportCallbackCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugReportCallbackCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags_ = {},
                                                            PFN_vkDebugReportCallbackEXT pfnCallback_ = {},
                                                            void* pUserData_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -29586,6 +31153,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDebugReportCallbackCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( this );
@@ -29596,6 +31164,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DebugReportCallbackCreateInfoEXT const& ) const = default;
 #else
@@ -29614,18 +31183,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags = {};
     PFN_vkDebugReportCallbackEXT pfnCallback = {};
     void* pUserData = {};
+
   };
   static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugReportCallbackCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDebugReportCallbackCreateInfoEXT>
+  {
+    using Type = DebugReportCallbackCreateInfoEXT;
+  };
+
   struct DebugUtilsLabelEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsLabelEXT;
+
     VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = {},
                                                 std::array<float,4> const& color_ = {} ) VULKAN_HPP_NOEXCEPT
       : pLabelName( pLabelName_ )
@@ -29667,6 +31247,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDebugUtilsLabelEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugUtilsLabelEXT*>( this );
@@ -29677,6 +31258,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugUtilsLabelEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DebugUtilsLabelEXT const& ) const = default;
 #else
@@ -29694,17 +31276,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsLabelEXT;
     const void* pNext = {};
     const char* pLabelName = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> color = {};
+
   };
   static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugUtilsLabelEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDebugUtilsLabelEXT>
+  {
+    using Type = DebugUtilsLabelEXT;
+  };
+
   struct DebugUtilsObjectNameInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsObjectNameInfoEXT;
+
     VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_ = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown,
                                                       uint64_t objectHandle_ = {},
                                                       const char* pObjectName_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -29754,6 +31347,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDebugUtilsObjectNameInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>( this );
@@ -29764,6 +31358,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DebugUtilsObjectNameInfoEXT const& ) const = default;
 #else
@@ -29782,18 +31377,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown;
     uint64_t objectHandle = {};
     const char* pObjectName = {};
+
   };
   static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugUtilsObjectNameInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDebugUtilsObjectNameInfoEXT>
+  {
+    using Type = DebugUtilsObjectNameInfoEXT;
+  };
+
   struct DebugUtilsMessengerCallbackDataEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsMessengerCallbackDataEXT;
+
     VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = {},
                                                                 const char* pMessageIdName_ = {},
                                                                 int32_t messageIdNumber_ = {},
@@ -29899,6 +31505,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDebugUtilsMessengerCallbackDataEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>( this );
@@ -29909,6 +31516,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DebugUtilsMessengerCallbackDataEXT const& ) const = default;
 #else
@@ -29934,6 +31542,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT;
     const void* pNext = {};
@@ -29947,12 +31557,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT* pCmdBufLabels = {};
     uint32_t objectCount = {};
     const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT* pObjects = {};
+
   };
   static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugUtilsMessengerCallbackDataEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDebugUtilsMessengerCallbackDataEXT>
+  {
+    using Type = DebugUtilsMessengerCallbackDataEXT;
+  };
+
   struct DebugUtilsMessengerCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags_ = {},
                                                            VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = {},
                                                            VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType_ = {},
@@ -30018,6 +31637,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDebugUtilsMessengerCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( this );
@@ -30028,6 +31648,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DebugUtilsMessengerCreateInfoEXT const& ) const = default;
 #else
@@ -30048,6 +31669,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
     const void* pNext = {};
@@ -30056,12 +31679,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType = {};
     PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback = {};
     void* pUserData = {};
+
   };
   static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugUtilsMessengerCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDebugUtilsMessengerCreateInfoEXT>
+  {
+    using Type = DebugUtilsMessengerCreateInfoEXT;
+  };
+
   struct DebugUtilsObjectTagInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsObjectTagInfoEXT;
+
     VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_ = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown,
                                                      uint64_t objectHandle_ = {},
                                                      uint64_t tagName_ = {},
@@ -30127,6 +31759,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDebugUtilsObjectTagInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>( this );
@@ -30137,6 +31770,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DebugUtilsObjectTagInfoEXT const& ) const = default;
 #else
@@ -30157,6 +31791,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT;
     const void* pNext = {};
@@ -30165,12 +31801,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint64_t tagName = {};
     size_t tagSize = {};
     const void* pTag = {};
+
   };
   static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugUtilsObjectTagInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDebugUtilsObjectTagInfoEXT>
+  {
+    using Type = DebugUtilsObjectTagInfoEXT;
+  };
+
   struct DedicatedAllocationBufferCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocation_ = {} ) VULKAN_HPP_NOEXCEPT
       : dedicatedAllocation( dedicatedAllocation_ )
     {}
@@ -30204,6 +31849,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDedicatedAllocationBufferCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>( this );
@@ -30214,6 +31860,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DedicatedAllocationBufferCreateInfoNV const& ) const = default;
 #else
@@ -30230,16 +31877,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocation = {};
+
   };
   static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DedicatedAllocationBufferCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDedicatedAllocationBufferCreateInfoNV>
+  {
+    using Type = DedicatedAllocationBufferCreateInfoNV;
+  };
+
   struct DedicatedAllocationImageCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationImageCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocation_ = {} ) VULKAN_HPP_NOEXCEPT
       : dedicatedAllocation( dedicatedAllocation_ )
     {}
@@ -30273,6 +31931,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDedicatedAllocationImageCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>( this );
@@ -30283,6 +31942,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DedicatedAllocationImageCreateInfoNV const& ) const = default;
 #else
@@ -30299,16 +31959,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocation = {};
+
   };
   static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DedicatedAllocationImageCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDedicatedAllocationImageCreateInfoNV>
+  {
+    using Type = DedicatedAllocationImageCreateInfoNV;
+  };
+
   struct DedicatedAllocationMemoryAllocateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
+
     VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( VULKAN_HPP_NAMESPACE::Image image_ = {},
                                                                   VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT
       : image( image_ )
@@ -30350,6 +32021,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDedicatedAllocationMemoryAllocateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>( this );
@@ -30360,6 +32032,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DedicatedAllocationMemoryAllocateInfoNV const& ) const = default;
 #else
@@ -30377,18 +32050,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Image image = {};
     VULKAN_HPP_NAMESPACE::Buffer buffer = {};
+
   };
   static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DedicatedAllocationMemoryAllocateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDedicatedAllocationMemoryAllocateInfoNV>
+  {
+    using Type = DedicatedAllocationMemoryAllocateInfoNV;
+  };
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct DeferredOperationInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeferredOperationInfoKHR;
+
     VULKAN_HPP_CONSTEXPR DeferredOperationInfoKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operationHandle_ = {} ) VULKAN_HPP_NOEXCEPT
       : operationHandle( operationHandle_ )
     {}
@@ -30422,6 +32106,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeferredOperationInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeferredOperationInfoKHR*>( this );
@@ -30432,6 +32117,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeferredOperationInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeferredOperationInfoKHR const& ) const = default;
 #else
@@ -30448,17 +32134,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeferredOperationInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeferredOperationKHR operationHandle = {};
+
   };
   static_assert( sizeof( DeferredOperationInfoKHR ) == sizeof( VkDeferredOperationInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeferredOperationInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eDeferredOperationInfoKHR>
+  {
+    using Type = DeferredOperationInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct DescriptorBufferInfo
   {
+
     VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {},
                                                VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {},
                                                VULKAN_HPP_NAMESPACE::DeviceSize range_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -30496,6 +32192,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorBufferInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorBufferInfo*>( this );
@@ -30506,6 +32203,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorBufferInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorBufferInfo const& ) const = default;
 #else
@@ -30522,16 +32220,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Buffer buffer = {};
     VULKAN_HPP_NAMESPACE::DeviceSize offset = {};
     VULKAN_HPP_NAMESPACE::DeviceSize range = {};
+
   };
   static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorBufferInfo>::value, "struct wrapper is not a standard layout!" );
 
   struct DescriptorImageInfo
   {
+
     VULKAN_HPP_CONSTEXPR DescriptorImageInfo( VULKAN_HPP_NAMESPACE::Sampler sampler_ = {},
                                               VULKAN_HPP_NAMESPACE::ImageView imageView_ = {},
                                               VULKAN_HPP_NAMESPACE::ImageLayout imageLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
@@ -30569,6 +32271,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorImageInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorImageInfo*>( this );
@@ -30579,6 +32282,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorImageInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorImageInfo const& ) const = default;
 #else
@@ -30595,16 +32299,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Sampler sampler = {};
     VULKAN_HPP_NAMESPACE::ImageView imageView = {};
     VULKAN_HPP_NAMESPACE::ImageLayout imageLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
+
   };
   static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorImageInfo>::value, "struct wrapper is not a standard layout!" );
 
   struct DescriptorPoolSize
   {
+
     VULKAN_HPP_CONSTEXPR DescriptorPoolSize( VULKAN_HPP_NAMESPACE::DescriptorType type_ = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler,
                                              uint32_t descriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT
       : type( type_ )
@@ -30634,6 +32342,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorPoolSize const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorPoolSize*>( this );
@@ -30644,6 +32353,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorPoolSize*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorPoolSize const& ) const = default;
 #else
@@ -30659,15 +32369,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DescriptorType type = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler;
     uint32_t descriptorCount = {};
+
   };
   static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorPoolSize>::value, "struct wrapper is not a standard layout!" );
 
   struct DescriptorPoolCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorPoolCreateInfo;
+
     VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags flags_ = {},
                                                    uint32_t maxSets_ = {},
                                                    uint32_t poolSizeCount_ = {},
@@ -30725,6 +32440,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorPoolCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>( this );
@@ -30735,6 +32451,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorPoolCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorPoolCreateInfo const& ) const = default;
 #else
@@ -30754,6 +32471,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorPoolCreateInfo;
     const void* pNext = {};
@@ -30761,12 +32480,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t maxSets = {};
     uint32_t poolSizeCount = {};
     const VULKAN_HPP_NAMESPACE::DescriptorPoolSize* pPoolSizes = {};
+
   };
   static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorPoolCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDescriptorPoolCreateInfo>
+  {
+    using Type = DescriptorPoolCreateInfo;
+  };
+
   struct DescriptorPoolInlineUniformBlockCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = {} ) VULKAN_HPP_NOEXCEPT
       : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
     {}
@@ -30800,6 +32528,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>( this );
@@ -30810,6 +32539,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfoEXT const& ) const = default;
 #else
@@ -30826,16 +32556,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT;
     const void* pNext = {};
     uint32_t maxInlineUniformBlockBindings = {};
+
   };
   static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorPoolInlineUniformBlockCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT>
+  {
+    using Type = DescriptorPoolInlineUniformBlockCreateInfoEXT;
+  };
+
   struct DescriptorSetAllocateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetAllocateInfo;
+
     VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool_ = {},
                                                     uint32_t descriptorSetCount_ = {},
                                                     const VULKAN_HPP_NAMESPACE::DescriptorSetLayout* pSetLayouts_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -30885,6 +32626,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorSetAllocateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetAllocateInfo*>( this );
@@ -30895,6 +32637,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetAllocateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorSetAllocateInfo const& ) const = default;
 #else
@@ -30913,18 +32656,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetAllocateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool = {};
     uint32_t descriptorSetCount = {};
     const VULKAN_HPP_NAMESPACE::DescriptorSetLayout* pSetLayouts = {};
+
   };
   static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorSetAllocateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDescriptorSetAllocateInfo>
+  {
+    using Type = DescriptorSetAllocateInfo;
+  };
+
   struct DescriptorSetLayoutBinding
   {
+
     VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( uint32_t binding_ = {},
                                                      VULKAN_HPP_NAMESPACE::DescriptorType descriptorType_ = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler,
                                                      uint32_t descriptorCount_ = {},
@@ -30978,6 +32731,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorSetLayoutBinding const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>( this );
@@ -30988,6 +32742,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetLayoutBinding*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorSetLayoutBinding const& ) const = default;
 #else
@@ -31006,18 +32761,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t binding = {};
     VULKAN_HPP_NAMESPACE::DescriptorType descriptorType = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler;
     uint32_t descriptorCount = {};
     VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags = {};
     const VULKAN_HPP_NAMESPACE::Sampler* pImmutableSamplers = {};
+
   };
   static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorSetLayoutBinding>::value, "struct wrapper is not a standard layout!" );
 
   struct DescriptorSetLayoutBindingFlagsCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo;
+
     VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfo( uint32_t bindingCount_ = {},
                                                                     const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags* pBindingFlags_ = {} ) VULKAN_HPP_NOEXCEPT
       : bindingCount( bindingCount_ )
@@ -31059,6 +32819,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorSetLayoutBindingFlagsCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>( this );
@@ -31069,6 +32830,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfo const& ) const = default;
 #else
@@ -31086,17 +32848,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo;
     const void* pNext = {};
     uint32_t bindingCount = {};
     const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags* pBindingFlags = {};
+
   };
   static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfo ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorSetLayoutBindingFlagsCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo>
+  {
+    using Type = DescriptorSetLayoutBindingFlagsCreateInfo;
+  };
+
   struct DescriptorSetLayoutCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutCreateInfo;
+
     VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags flags_ = {},
                                                         uint32_t bindingCount_ = {},
                                                         const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding* pBindings_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -31146,6 +32919,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorSetLayoutCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( this );
@@ -31156,6 +32930,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorSetLayoutCreateInfo const& ) const = default;
 #else
@@ -31174,18 +32949,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags flags = {};
     uint32_t bindingCount = {};
     const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding* pBindings = {};
+
   };
   static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorSetLayoutCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDescriptorSetLayoutCreateInfo>
+  {
+    using Type = DescriptorSetLayoutCreateInfo;
+  };
+
   struct DescriptorSetLayoutSupport
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutSupport;
+
     VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( VULKAN_HPP_NAMESPACE::Bool32 supported_ = {} ) VULKAN_HPP_NOEXCEPT
       : supported( supported_ )
     {}
@@ -31207,6 +32993,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorSetLayoutSupport const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutSupport*>( this );
@@ -31217,6 +33004,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetLayoutSupport*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorSetLayoutSupport const& ) const = default;
 #else
@@ -31233,16 +33021,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetLayoutSupport;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 supported = {};
+
   };
   static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorSetLayoutSupport>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDescriptorSetLayoutSupport>
+  {
+    using Type = DescriptorSetLayoutSupport;
+  };
+
   struct DescriptorSetVariableDescriptorCountAllocateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo;
+
     VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfo( uint32_t descriptorSetCount_ = {},
                                                                            const uint32_t* pDescriptorCounts_ = {} ) VULKAN_HPP_NOEXCEPT
       : descriptorSetCount( descriptorSetCount_ )
@@ -31284,6 +33083,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorSetVariableDescriptorCountAllocateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>( this );
@@ -31294,6 +33094,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfo const& ) const = default;
 #else
@@ -31311,17 +33112,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo;
     const void* pNext = {};
     uint32_t descriptorSetCount = {};
     const uint32_t* pDescriptorCounts = {};
+
   };
   static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfo ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorSetVariableDescriptorCountAllocateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo>
+  {
+    using Type = DescriptorSetVariableDescriptorCountAllocateInfo;
+  };
+
   struct DescriptorSetVariableDescriptorCountLayoutSupport
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport;
+
     VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountLayoutSupport( uint32_t maxVariableDescriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT
       : maxVariableDescriptorCount( maxVariableDescriptorCount_ )
     {}
@@ -31343,6 +33155,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorSetVariableDescriptorCountLayoutSupport const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>( this );
@@ -31353,6 +33166,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupport const& ) const = default;
 #else
@@ -31369,16 +33183,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport;
     void* pNext = {};
     uint32_t maxVariableDescriptorCount = {};
+
   };
   static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupport ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupport ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorSetVariableDescriptorCountLayoutSupport>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport>
+  {
+    using Type = DescriptorSetVariableDescriptorCountLayoutSupport;
+  };
+
   struct DescriptorUpdateTemplateEntry
   {
+
     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = {},
                                                         uint32_t dstArrayElement_ = {},
                                                         uint32_t descriptorCount_ = {},
@@ -31440,6 +33264,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorUpdateTemplateEntry const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorUpdateTemplateEntry*>( this );
@@ -31450,6 +33275,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorUpdateTemplateEntry const& ) const = default;
 #else
@@ -31469,6 +33295,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t dstBinding = {};
     uint32_t dstArrayElement = {};
@@ -31476,12 +33304,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DescriptorType descriptorType = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler;
     size_t offset = {};
     size_t stride = {};
+
   };
   static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorUpdateTemplateEntry>::value, "struct wrapper is not a standard layout!" );
 
   struct DescriptorUpdateTemplateCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorUpdateTemplateCreateInfo;
+
     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags flags_ = {},
                                                              uint32_t descriptorUpdateEntryCount_ = {},
                                                              const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = {},
@@ -31571,6 +33402,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDescriptorUpdateTemplateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( this );
@@ -31581,6 +33413,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DescriptorUpdateTemplateCreateInfo const& ) const = default;
 #else
@@ -31604,6 +33437,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
     const void* pNext = {};
@@ -31615,12 +33450,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics;
     VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout = {};
     uint32_t set = {};
+
   };
   static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorUpdateTemplateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDescriptorUpdateTemplateCreateInfo>
+  {
+    using Type = DescriptorUpdateTemplateCreateInfo;
+  };
+
   struct DeviceQueueCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueCreateInfo;
+
     VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags flags_ = {},
                                                 uint32_t queueFamilyIndex_ = {},
                                                 uint32_t queueCount_ = {},
@@ -31678,6 +33522,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceQueueCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceQueueCreateInfo*>( this );
@@ -31688,6 +33533,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceQueueCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceQueueCreateInfo const& ) const = default;
 #else
@@ -31707,6 +33553,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceQueueCreateInfo;
     const void* pNext = {};
@@ -31714,12 +33562,20 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t queueFamilyIndex = {};
     uint32_t queueCount = {};
     const float* pQueuePriorities = {};
+
   };
   static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceQueueCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceQueueCreateInfo>
+  {
+    using Type = DeviceQueueCreateInfo;
+  };
+
   struct PhysicalDeviceFeatures
   {
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess_ = {},
                                                  VULKAN_HPP_NAMESPACE::Bool32 fullDrawIndexUint32_ = {},
                                                  VULKAN_HPP_NAMESPACE::Bool32 imageCubeArray_ = {},
@@ -32173,6 +34029,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFeatures*>( this );
@@ -32183,6 +34040,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceFeatures const& ) const = default;
 #else
@@ -32251,6 +34109,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess = {};
     VULKAN_HPP_NAMESPACE::Bool32 fullDrawIndexUint32 = {};
@@ -32307,12 +34167,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 sparseResidencyAliased = {};
     VULKAN_HPP_NAMESPACE::Bool32 variableMultisampleRate = {};
     VULKAN_HPP_NAMESPACE::Bool32 inheritedQueries = {};
+
   };
   static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFeatures>::value, "struct wrapper is not a standard layout!" );
 
   struct DeviceCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceCreateInfo;
+
     VULKAN_HPP_CONSTEXPR DeviceCreateInfo( VULKAN_HPP_NAMESPACE::DeviceCreateFlags flags_ = {},
                                            uint32_t queueCreateInfoCount_ = {},
                                            const VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo* pQueueCreateInfos_ = {},
@@ -32402,6 +34265,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceCreateInfo*>( this );
@@ -32412,6 +34276,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceCreateInfo const& ) const = default;
 #else
@@ -32435,6 +34300,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceCreateInfo;
     const void* pNext = {};
@@ -32446,12 +34313,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t enabledExtensionCount = {};
     const char* const* ppEnabledExtensionNames = {};
     const VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures* pEnabledFeatures = {};
+
   };
   static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceCreateInfo>
+  {
+    using Type = DeviceCreateInfo;
+  };
+
   struct DeviceDiagnosticsConfigCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceDiagnosticsConfigCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigCreateInfoNV( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV flags_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
     {}
@@ -32485,6 +34361,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceDiagnosticsConfigCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>( this );
@@ -32495,6 +34372,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceDiagnosticsConfigCreateInfoNV const& ) const = default;
 #else
@@ -32511,16 +34389,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceDiagnosticsConfigCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV flags = {};
+
   };
   static_assert( sizeof( DeviceDiagnosticsConfigCreateInfoNV ) == sizeof( VkDeviceDiagnosticsConfigCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceDiagnosticsConfigCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceDiagnosticsConfigCreateInfoNV>
+  {
+    using Type = DeviceDiagnosticsConfigCreateInfoNV;
+  };
+
   struct DeviceEventInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceEventInfoEXT;
+
     VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT deviceEvent_ = VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT::eDisplayHotplug ) VULKAN_HPP_NOEXCEPT
       : deviceEvent( deviceEvent_ )
     {}
@@ -32554,6 +34443,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceEventInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceEventInfoEXT*>( this );
@@ -32564,6 +34454,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceEventInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceEventInfoEXT const& ) const = default;
 #else
@@ -32580,16 +34471,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceEventInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT deviceEvent = VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT::eDisplayHotplug;
+
   };
   static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceEventInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceEventInfoEXT>
+  {
+    using Type = DeviceEventInfoEXT;
+  };
+
   struct DeviceGroupBindSparseInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupBindSparseInfo;
+
     VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = {},
                                                     uint32_t memoryDeviceIndex_ = {} ) VULKAN_HPP_NOEXCEPT
       : resourceDeviceIndex( resourceDeviceIndex_ )
@@ -32631,6 +34533,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceGroupBindSparseInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupBindSparseInfo*>( this );
@@ -32641,6 +34544,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupBindSparseInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceGroupBindSparseInfo const& ) const = default;
 #else
@@ -32658,17 +34562,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupBindSparseInfo;
     const void* pNext = {};
     uint32_t resourceDeviceIndex = {};
     uint32_t memoryDeviceIndex = {};
+
   };
   static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupBindSparseInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceGroupBindSparseInfo>
+  {
+    using Type = DeviceGroupBindSparseInfo;
+  };
+
   struct DeviceGroupCommandBufferBeginInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupCommandBufferBeginInfo;
+
     VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = {} ) VULKAN_HPP_NOEXCEPT
       : deviceMask( deviceMask_ )
     {}
@@ -32702,6 +34617,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceGroupCommandBufferBeginInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>( this );
@@ -32712,6 +34628,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceGroupCommandBufferBeginInfo const& ) const = default;
 #else
@@ -32728,16 +34645,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo;
     const void* pNext = {};
     uint32_t deviceMask = {};
+
   };
   static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupCommandBufferBeginInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceGroupCommandBufferBeginInfo>
+  {
+    using Type = DeviceGroupCommandBufferBeginInfo;
+  };
+
   struct DeviceGroupDeviceCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupDeviceCreateInfo;
+
     VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = {},
                                                       const VULKAN_HPP_NAMESPACE::PhysicalDevice* pPhysicalDevices_ = {} ) VULKAN_HPP_NOEXCEPT
       : physicalDeviceCount( physicalDeviceCount_ )
@@ -32779,6 +34707,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceGroupDeviceCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>( this );
@@ -32789,6 +34718,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceGroupDeviceCreateInfo const& ) const = default;
 #else
@@ -32806,17 +34736,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo;
     const void* pNext = {};
     uint32_t physicalDeviceCount = {};
     const VULKAN_HPP_NAMESPACE::PhysicalDevice* pPhysicalDevices = {};
+
   };
   static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupDeviceCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceGroupDeviceCreateInfo>
+  {
+    using Type = DeviceGroupDeviceCreateInfo;
+  };
+
   struct DeviceGroupPresentCapabilitiesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupPresentCapabilitiesKHR;
+
     VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentCapabilitiesKHR( std::array<uint32_t,VK_MAX_DEVICE_GROUP_SIZE> const& presentMask_ = {},
                                                                VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes_ = {} ) VULKAN_HPP_NOEXCEPT
       : presentMask( presentMask_ )
@@ -32840,6 +34781,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceGroupPresentCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>( this );
@@ -32850,6 +34792,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceGroupPresentCapabilitiesKHR const& ) const = default;
 #else
@@ -32867,17 +34810,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, VK_MAX_DEVICE_GROUP_SIZE> presentMask = {};
     VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes = {};
+
   };
   static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupPresentCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceGroupPresentCapabilitiesKHR>
+  {
+    using Type = DeviceGroupPresentCapabilitiesKHR;
+  };
+
   struct DeviceGroupPresentInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupPresentInfoKHR;
+
     VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = {},
                                                     const uint32_t* pDeviceMasks_ = {},
                                                     VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR mode_ = VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR::eLocal ) VULKAN_HPP_NOEXCEPT
@@ -32927,6 +34881,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceGroupPresentInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>( this );
@@ -32937,6 +34892,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceGroupPresentInfoKHR const& ) const = default;
 #else
@@ -32955,18 +34911,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupPresentInfoKHR;
     const void* pNext = {};
     uint32_t swapchainCount = {};
     const uint32_t* pDeviceMasks = {};
     VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR mode = VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR::eLocal;
+
   };
   static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupPresentInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceGroupPresentInfoKHR>
+  {
+    using Type = DeviceGroupPresentInfoKHR;
+  };
+
   struct DeviceGroupRenderPassBeginInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupRenderPassBeginInfo;
+
     VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = {},
                                                          uint32_t deviceRenderAreaCount_ = {},
                                                          const VULKAN_HPP_NAMESPACE::Rect2D* pDeviceRenderAreas_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -33016,6 +34983,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceGroupRenderPassBeginInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>( this );
@@ -33026,6 +34994,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceGroupRenderPassBeginInfo const& ) const = default;
 #else
@@ -33044,18 +35013,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo;
     const void* pNext = {};
     uint32_t deviceMask = {};
     uint32_t deviceRenderAreaCount = {};
     const VULKAN_HPP_NAMESPACE::Rect2D* pDeviceRenderAreas = {};
+
   };
   static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupRenderPassBeginInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceGroupRenderPassBeginInfo>
+  {
+    using Type = DeviceGroupRenderPassBeginInfo;
+  };
+
   struct DeviceGroupSubmitInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupSubmitInfo;
+
     VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = {},
                                                 const uint32_t* pWaitSemaphoreDeviceIndices_ = {},
                                                 uint32_t commandBufferCount_ = {},
@@ -33129,6 +35109,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceGroupSubmitInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupSubmitInfo*>( this );
@@ -33139,6 +35120,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupSubmitInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceGroupSubmitInfo const& ) const = default;
 #else
@@ -33160,6 +35142,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupSubmitInfo;
     const void* pNext = {};
@@ -33169,12 +35153,21 @@ namespace VULKAN_HPP_NAMESPACE
     const uint32_t* pCommandBufferDeviceMasks = {};
     uint32_t signalSemaphoreCount = {};
     const uint32_t* pSignalSemaphoreDeviceIndices = {};
+
   };
   static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupSubmitInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceGroupSubmitInfo>
+  {
+    using Type = DeviceGroupSubmitInfo;
+  };
+
   struct DeviceGroupSwapchainCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupSwapchainCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes_ = {} ) VULKAN_HPP_NOEXCEPT
       : modes( modes_ )
     {}
@@ -33208,6 +35201,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceGroupSwapchainCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>( this );
@@ -33218,6 +35212,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceGroupSwapchainCreateInfoKHR const& ) const = default;
 #else
@@ -33234,16 +35229,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes = {};
+
   };
   static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupSwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceGroupSwapchainCreateInfoKHR>
+  {
+    using Type = DeviceGroupSwapchainCreateInfoKHR;
+  };
+
   struct DeviceMemoryOpaqueCaptureAddressInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryOpaqueCaptureAddressInfo;
+
     VULKAN_HPP_CONSTEXPR DeviceMemoryOpaqueCaptureAddressInfo( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {} ) VULKAN_HPP_NOEXCEPT
       : memory( memory_ )
     {}
@@ -33277,6 +35283,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceMemoryOpaqueCaptureAddressInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>( this );
@@ -33287,6 +35294,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceMemoryOpaqueCaptureAddressInfo const& ) const = default;
 #else
@@ -33303,16 +35311,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceMemoryOpaqueCaptureAddressInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
+
   };
   static_assert( sizeof( DeviceMemoryOpaqueCaptureAddressInfo ) == sizeof( VkDeviceMemoryOpaqueCaptureAddressInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceMemoryOpaqueCaptureAddressInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceMemoryOpaqueCaptureAddressInfo>
+  {
+    using Type = DeviceMemoryOpaqueCaptureAddressInfo;
+  };
+
   struct DeviceMemoryOverallocationCreateInfoAMD
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD;
+
     VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD overallocationBehavior_ = VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD::eDefault ) VULKAN_HPP_NOEXCEPT
       : overallocationBehavior( overallocationBehavior_ )
     {}
@@ -33346,6 +35365,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceMemoryOverallocationCreateInfoAMD const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>( this );
@@ -33356,6 +35376,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceMemoryOverallocationCreateInfoAMD const& ) const = default;
 #else
@@ -33372,16 +35393,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD overallocationBehavior = VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD::eDefault;
+
   };
   static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceMemoryOverallocationCreateInfoAMD>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceMemoryOverallocationCreateInfoAMD>
+  {
+    using Type = DeviceMemoryOverallocationCreateInfoAMD;
+  };
+
   struct DeviceQueueGlobalPriorityCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT globalPriority_ = VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT::eLow ) VULKAN_HPP_NOEXCEPT
       : globalPriority( globalPriority_ )
     {}
@@ -33415,6 +35447,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceQueueGlobalPriorityCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>( this );
@@ -33425,6 +35458,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceQueueGlobalPriorityCreateInfoEXT const& ) const = default;
 #else
@@ -33441,16 +35475,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT globalPriority = VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT::eLow;
+
   };
   static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceQueueGlobalPriorityCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT>
+  {
+    using Type = DeviceQueueGlobalPriorityCreateInfoEXT;
+  };
+
   struct DeviceQueueInfo2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueInfo2;
+
     VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags flags_ = {},
                                            uint32_t queueFamilyIndex_ = {},
                                            uint32_t queueIndex_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -33500,6 +35545,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDeviceQueueInfo2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDeviceQueueInfo2*>( this );
@@ -33510,6 +35556,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceQueueInfo2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DeviceQueueInfo2 const& ) const = default;
 #else
@@ -33528,18 +35575,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceQueueInfo2;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags flags = {};
     uint32_t queueFamilyIndex = {};
     uint32_t queueIndex = {};
+
   };
   static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceQueueInfo2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDeviceQueueInfo2>
+  {
+    using Type = DeviceQueueInfo2;
+  };
+
   struct DispatchIndirectCommand
   {
+
     VULKAN_HPP_CONSTEXPR DispatchIndirectCommand( uint32_t x_ = {},
                                                   uint32_t y_ = {},
                                                   uint32_t z_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -33577,6 +35634,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDispatchIndirectCommand const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDispatchIndirectCommand*>( this );
@@ -33587,6 +35645,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDispatchIndirectCommand*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DispatchIndirectCommand const& ) const = default;
 #else
@@ -33603,16 +35662,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t x = {};
     uint32_t y = {};
     uint32_t z = {};
+
   };
   static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DispatchIndirectCommand>::value, "struct wrapper is not a standard layout!" );
 
   struct DisplayEventInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayEventInfoEXT;
+
     VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT displayEvent_ = VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT::eFirstPixelOut ) VULKAN_HPP_NOEXCEPT
       : displayEvent( displayEvent_ )
     {}
@@ -33646,6 +35710,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayEventInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayEventInfoEXT*>( this );
@@ -33656,6 +35721,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayEventInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayEventInfoEXT const& ) const = default;
 #else
@@ -33672,16 +35738,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayEventInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT displayEvent = VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT::eFirstPixelOut;
+
   };
   static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayEventInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDisplayEventInfoEXT>
+  {
+    using Type = DisplayEventInfoEXT;
+  };
+
   struct DisplayModeParametersKHR
   {
+
     VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( VULKAN_HPP_NAMESPACE::Extent2D visibleRegion_ = {},
                                                    uint32_t refreshRate_ = {} ) VULKAN_HPP_NOEXCEPT
       : visibleRegion( visibleRegion_ )
@@ -33699,7 +35775,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplayModeParametersKHR & setVisibleRegion( VULKAN_HPP_NAMESPACE::Extent2D visibleRegion_ ) VULKAN_HPP_NOEXCEPT
+    DisplayModeParametersKHR & setVisibleRegion( VULKAN_HPP_NAMESPACE::Extent2D const & visibleRegion_ ) VULKAN_HPP_NOEXCEPT
     {
       visibleRegion = visibleRegion_;
       return *this;
@@ -33711,6 +35787,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayModeParametersKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayModeParametersKHR*>( this );
@@ -33721,6 +35798,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayModeParametersKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayModeParametersKHR const& ) const = default;
 #else
@@ -33736,15 +35814,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Extent2D visibleRegion = {};
     uint32_t refreshRate = {};
+
   };
   static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayModeParametersKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct DisplayModeCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR flags_ = {},
                                                    VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -33780,12 +35863,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplayModeCreateInfoKHR & setParameters( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters_ ) VULKAN_HPP_NOEXCEPT
+    DisplayModeCreateInfoKHR & setParameters( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & parameters_ ) VULKAN_HPP_NOEXCEPT
     {
       parameters = parameters_;
       return *this;
     }
 
+
     operator VkDisplayModeCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( this );
@@ -33796,6 +35880,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayModeCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayModeCreateInfoKHR const& ) const = default;
 #else
@@ -33813,17 +35898,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR flags = {};
     VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters = {};
+
   };
   static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayModeCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDisplayModeCreateInfoKHR>
+  {
+    using Type = DisplayModeCreateInfoKHR;
+  };
+
   struct DisplayModePropertiesKHR
   {
+
     VULKAN_HPP_CONSTEXPR DisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode_ = {},
                                                    VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters_ = {} ) VULKAN_HPP_NOEXCEPT
       : displayMode( displayMode_ )
@@ -33841,6 +35936,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayModePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayModePropertiesKHR*>( this );
@@ -33851,6 +35947,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayModePropertiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayModePropertiesKHR const& ) const = default;
 #else
@@ -33866,15 +35963,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode = {};
     VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters = {};
+
   };
   static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayModePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct DisplayModeProperties2KHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeProperties2KHR;
+
     VULKAN_HPP_CONSTEXPR DisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR displayModeProperties_ = {} ) VULKAN_HPP_NOEXCEPT
       : displayModeProperties( displayModeProperties_ )
     {}
@@ -33896,6 +35998,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayModeProperties2KHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayModeProperties2KHR*>( this );
@@ -33906,6 +36009,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayModeProperties2KHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayModeProperties2KHR const& ) const = default;
 #else
@@ -33922,16 +36026,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayModeProperties2KHR;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR displayModeProperties = {};
+
   };
   static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayModeProperties2KHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDisplayModeProperties2KHR>
+  {
+    using Type = DisplayModeProperties2KHR;
+  };
+
   struct DisplayNativeHdrSurfaceCapabilitiesAMD
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD;
+
     VULKAN_HPP_CONSTEXPR DisplayNativeHdrSurfaceCapabilitiesAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingSupport_ = {} ) VULKAN_HPP_NOEXCEPT
       : localDimmingSupport( localDimmingSupport_ )
     {}
@@ -33953,6 +36068,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>( this );
@@ -33963,6 +36079,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayNativeHdrSurfaceCapabilitiesAMD const& ) const = default;
 #else
@@ -33979,16 +36096,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 localDimmingSupport = {};
+
   };
   static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayNativeHdrSurfaceCapabilitiesAMD>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD>
+  {
+    using Type = DisplayNativeHdrSurfaceCapabilitiesAMD;
+  };
+
   struct DisplayPlaneCapabilitiesKHR
   {
+
     VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR supportedAlpha_ = {},
                                                       VULKAN_HPP_NAMESPACE::Offset2D minSrcPosition_ = {},
                                                       VULKAN_HPP_NAMESPACE::Offset2D maxSrcPosition_ = {},
@@ -34020,6 +36147,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayPlaneCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>( this );
@@ -34030,6 +36158,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayPlaneCapabilitiesKHR const& ) const = default;
 #else
@@ -34052,6 +36181,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR supportedAlpha = {};
     VULKAN_HPP_NAMESPACE::Offset2D minSrcPosition = {};
@@ -34062,12 +36193,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Offset2D maxDstPosition = {};
     VULKAN_HPP_NAMESPACE::Extent2D minDstExtent = {};
     VULKAN_HPP_NAMESPACE::Extent2D maxDstExtent = {};
+
   };
   static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPlaneCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct DisplayPlaneCapabilities2KHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneCapabilities2KHR;
+
     VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilities2KHR( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities_ = {} ) VULKAN_HPP_NOEXCEPT
       : capabilities( capabilities_ )
     {}
@@ -34089,6 +36223,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayPlaneCapabilities2KHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>( this );
@@ -34099,6 +36234,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayPlaneCapabilities2KHR const& ) const = default;
 #else
@@ -34115,16 +36251,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities = {};
+
   };
   static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPlaneCapabilities2KHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDisplayPlaneCapabilities2KHR>
+  {
+    using Type = DisplayPlaneCapabilities2KHR;
+  };
+
   struct DisplayPlaneInfo2KHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneInfo2KHR;
+
     VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode_ = {},
                                                uint32_t planeIndex_ = {} ) VULKAN_HPP_NOEXCEPT
       : mode( mode_ )
@@ -34166,6 +36313,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayPlaneInfo2KHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( this );
@@ -34176,6 +36324,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPlaneInfo2KHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayPlaneInfo2KHR const& ) const = default;
 #else
@@ -34193,17 +36342,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPlaneInfo2KHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DisplayModeKHR mode = {};
     uint32_t planeIndex = {};
+
   };
   static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPlaneInfo2KHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDisplayPlaneInfo2KHR>
+  {
+    using Type = DisplayPlaneInfo2KHR;
+  };
+
   struct DisplayPlanePropertiesKHR
   {
+
     VULKAN_HPP_CONSTEXPR DisplayPlanePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR currentDisplay_ = {},
                                                     uint32_t currentStackIndex_ = {} ) VULKAN_HPP_NOEXCEPT
       : currentDisplay( currentDisplay_ )
@@ -34221,6 +36380,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayPlanePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>( this );
@@ -34231,6 +36391,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPlanePropertiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayPlanePropertiesKHR const& ) const = default;
 #else
@@ -34246,15 +36407,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DisplayKHR currentDisplay = {};
     uint32_t currentStackIndex = {};
+
   };
   static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPlanePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct DisplayPlaneProperties2KHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneProperties2KHR;
+
     VULKAN_HPP_CONSTEXPR DisplayPlaneProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR displayPlaneProperties_ = {} ) VULKAN_HPP_NOEXCEPT
       : displayPlaneProperties( displayPlaneProperties_ )
     {}
@@ -34276,6 +36442,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayPlaneProperties2KHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPlaneProperties2KHR*>( this );
@@ -34286,6 +36453,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPlaneProperties2KHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayPlaneProperties2KHR const& ) const = default;
 #else
@@ -34302,16 +36470,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPlaneProperties2KHR;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR displayPlaneProperties = {};
+
   };
   static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPlaneProperties2KHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDisplayPlaneProperties2KHR>
+  {
+    using Type = DisplayPlaneProperties2KHR;
+  };
+
   struct DisplayPowerInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPowerInfoEXT;
+
     VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT powerState_ = VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT::eOff ) VULKAN_HPP_NOEXCEPT
       : powerState( powerState_ )
     {}
@@ -34345,6 +36524,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayPowerInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPowerInfoEXT*>( this );
@@ -34355,6 +36535,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPowerInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayPowerInfoEXT const& ) const = default;
 #else
@@ -34371,16 +36552,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPowerInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT powerState = VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT::eOff;
+
   };
   static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPowerInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDisplayPowerInfoEXT>
+  {
+    using Type = DisplayPowerInfoEXT;
+  };
+
   struct DisplayPresentInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPresentInfoKHR;
+
     VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( VULKAN_HPP_NAMESPACE::Rect2D srcRect_ = {},
                                                 VULKAN_HPP_NAMESPACE::Rect2D dstRect_ = {},
                                                 VULKAN_HPP_NAMESPACE::Bool32 persistent_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -34412,13 +36604,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplayPresentInfoKHR & setSrcRect( VULKAN_HPP_NAMESPACE::Rect2D srcRect_ ) VULKAN_HPP_NOEXCEPT
+    DisplayPresentInfoKHR & setSrcRect( VULKAN_HPP_NAMESPACE::Rect2D const & srcRect_ ) VULKAN_HPP_NOEXCEPT
     {
       srcRect = srcRect_;
       return *this;
     }
 
-    DisplayPresentInfoKHR & setDstRect( VULKAN_HPP_NAMESPACE::Rect2D dstRect_ ) VULKAN_HPP_NOEXCEPT
+    DisplayPresentInfoKHR & setDstRect( VULKAN_HPP_NAMESPACE::Rect2D const & dstRect_ ) VULKAN_HPP_NOEXCEPT
     {
       dstRect = dstRect_;
       return *this;
@@ -34430,6 +36622,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayPresentInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPresentInfoKHR*>( this );
@@ -34440,6 +36633,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPresentInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayPresentInfoKHR const& ) const = default;
 #else
@@ -34458,18 +36652,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPresentInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Rect2D srcRect = {};
     VULKAN_HPP_NAMESPACE::Rect2D dstRect = {};
     VULKAN_HPP_NAMESPACE::Bool32 persistent = {};
+
   };
   static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPresentInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDisplayPresentInfoKHR>
+  {
+    using Type = DisplayPresentInfoKHR;
+  };
+
   struct DisplayPropertiesKHR
   {
+
     VULKAN_HPP_CONSTEXPR DisplayPropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display_ = {},
                                                const char* displayName_ = {},
                                                VULKAN_HPP_NAMESPACE::Extent2D physicalDimensions_ = {},
@@ -34497,6 +36701,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayPropertiesKHR*>( this );
@@ -34507,6 +36712,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPropertiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayPropertiesKHR const& ) const = default;
 #else
@@ -34527,6 +36733,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DisplayKHR display = {};
     const char* displayName = {};
@@ -34535,12 +36743,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR supportedTransforms = {};
     VULKAN_HPP_NAMESPACE::Bool32 planeReorderPossible = {};
     VULKAN_HPP_NAMESPACE::Bool32 persistentContent = {};
+
   };
   static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct DisplayProperties2KHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayProperties2KHR;
+
     VULKAN_HPP_CONSTEXPR DisplayProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR displayProperties_ = {} ) VULKAN_HPP_NOEXCEPT
       : displayProperties( displayProperties_ )
     {}
@@ -34562,6 +36773,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDisplayProperties2KHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplayProperties2KHR*>( this );
@@ -34572,6 +36784,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayProperties2KHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplayProperties2KHR const& ) const = default;
 #else
@@ -34588,16 +36801,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayProperties2KHR;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR displayProperties = {};
+
   };
   static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayProperties2KHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDisplayProperties2KHR>
+  {
+    using Type = DisplayProperties2KHR;
+  };
+
   struct DisplaySurfaceCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplaySurfaceCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR flags_ = {},
                                                       VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode_ = {},
                                                       uint32_t planeIndex_ = {},
@@ -34681,12 +36905,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplaySurfaceCreateInfoKHR & setImageExtent( VULKAN_HPP_NAMESPACE::Extent2D imageExtent_ ) VULKAN_HPP_NOEXCEPT
+    DisplaySurfaceCreateInfoKHR & setImageExtent( VULKAN_HPP_NAMESPACE::Extent2D const & imageExtent_ ) VULKAN_HPP_NOEXCEPT
     {
       imageExtent = imageExtent_;
       return *this;
     }
 
+
     operator VkDisplaySurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( this );
@@ -34697,6 +36922,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DisplaySurfaceCreateInfoKHR const& ) const = default;
 #else
@@ -34720,6 +36946,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
     const void* pNext = {};
@@ -34731,12 +36959,20 @@ namespace VULKAN_HPP_NAMESPACE
     float globalAlpha = {};
     VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR alphaMode = VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR::eOpaque;
     VULKAN_HPP_NAMESPACE::Extent2D imageExtent = {};
+
   };
   static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplaySurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDisplaySurfaceCreateInfoKHR>
+  {
+    using Type = DisplaySurfaceCreateInfoKHR;
+  };
+
   struct DrawIndexedIndirectCommand
   {
+
     VULKAN_HPP_CONSTEXPR DrawIndexedIndirectCommand( uint32_t indexCount_ = {},
                                                      uint32_t instanceCount_ = {},
                                                      uint32_t firstIndex_ = {},
@@ -34790,6 +37026,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDrawIndexedIndirectCommand const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrawIndexedIndirectCommand*>( this );
@@ -34800,6 +37037,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrawIndexedIndirectCommand*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DrawIndexedIndirectCommand const& ) const = default;
 #else
@@ -34818,18 +37056,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t indexCount = {};
     uint32_t instanceCount = {};
     uint32_t firstIndex = {};
     int32_t vertexOffset = {};
     uint32_t firstInstance = {};
+
   };
   static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DrawIndexedIndirectCommand>::value, "struct wrapper is not a standard layout!" );
 
   struct DrawIndirectCommand
   {
+
     VULKAN_HPP_CONSTEXPR DrawIndirectCommand( uint32_t vertexCount_ = {},
                                               uint32_t instanceCount_ = {},
                                               uint32_t firstVertex_ = {},
@@ -34875,6 +37117,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDrawIndirectCommand const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrawIndirectCommand*>( this );
@@ -34885,6 +37128,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrawIndirectCommand*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DrawIndirectCommand const& ) const = default;
 #else
@@ -34902,17 +37146,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t vertexCount = {};
     uint32_t instanceCount = {};
     uint32_t firstVertex = {};
     uint32_t firstInstance = {};
+
   };
   static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DrawIndirectCommand>::value, "struct wrapper is not a standard layout!" );
 
   struct DrawMeshTasksIndirectCommandNV
   {
+
     VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = {},
                                                          uint32_t firstTask_ = {} ) VULKAN_HPP_NOEXCEPT
       : taskCount( taskCount_ )
@@ -34942,6 +37190,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDrawMeshTasksIndirectCommandNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrawMeshTasksIndirectCommandNV*>( this );
@@ -34952,6 +37201,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DrawMeshTasksIndirectCommandNV const& ) const = default;
 #else
@@ -34967,15 +37217,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t taskCount = {};
     uint32_t firstTask = {};
+
   };
   static_assert( sizeof( DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DrawMeshTasksIndirectCommandNV>::value, "struct wrapper is not a standard layout!" );
 
   struct DrmFormatModifierPropertiesEXT
   {
+
     VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = {},
                                                          uint32_t drmFormatModifierPlaneCount_ = {},
                                                          VULKAN_HPP_NAMESPACE::FormatFeatureFlags drmFormatModifierTilingFeatures_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -34995,6 +37249,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDrmFormatModifierPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrmFormatModifierPropertiesEXT*>( this );
@@ -35005,6 +37260,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrmFormatModifierPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DrmFormatModifierPropertiesEXT const& ) const = default;
 #else
@@ -35021,16 +37277,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint64_t drmFormatModifier = {};
     uint32_t drmFormatModifierPlaneCount = {};
     VULKAN_HPP_NAMESPACE::FormatFeatureFlags drmFormatModifierTilingFeatures = {};
+
   };
   static_assert( sizeof( DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DrmFormatModifierPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct DrmFormatModifierPropertiesListEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDrmFormatModifierPropertiesListEXT;
+
     VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = {},
                                                              VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ = {} ) VULKAN_HPP_NOEXCEPT
       : drmFormatModifierCount( drmFormatModifierCount_ )
@@ -35054,6 +37315,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkDrmFormatModifierPropertiesListEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>( this );
@@ -35064,6 +37326,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( DrmFormatModifierPropertiesListEXT const& ) const = default;
 #else
@@ -35081,17 +37344,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT;
     void* pNext = {};
     uint32_t drmFormatModifierCount = {};
     VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties = {};
+
   };
   static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DrmFormatModifierPropertiesListEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eDrmFormatModifierPropertiesListEXT>
+  {
+    using Type = DrmFormatModifierPropertiesListEXT;
+  };
+
   struct EventCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eEventCreateInfo;
+
     VULKAN_HPP_CONSTEXPR EventCreateInfo( VULKAN_HPP_NAMESPACE::EventCreateFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
     {}
@@ -35125,6 +37399,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkEventCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkEventCreateInfo*>( this );
@@ -35135,6 +37410,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkEventCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( EventCreateInfo const& ) const = default;
 #else
@@ -35151,16 +37427,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eEventCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::EventCreateFlags flags = {};
+
   };
   static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<EventCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eEventCreateInfo>
+  {
+    using Type = EventCreateInfo;
+  };
+
   struct ExportFenceCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportFenceCreateInfo;
+
     VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT
       : handleTypes( handleTypes_ )
     {}
@@ -35194,6 +37481,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExportFenceCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportFenceCreateInfo*>( this );
@@ -35204,6 +37492,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportFenceCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExportFenceCreateInfo const& ) const = default;
 #else
@@ -35220,17 +37509,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportFenceCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags handleTypes = {};
+
   };
   static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportFenceCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eExportFenceCreateInfo>
+  {
+    using Type = ExportFenceCreateInfo;
+  };
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct ExportFenceWin32HandleInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportFenceWin32HandleInfoKHR;
+
     VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = {},
                                                         DWORD dwAccess_ = {},
                                                         LPCWSTR name_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -35280,6 +37580,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExportFenceWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>( this );
@@ -35290,6 +37591,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExportFenceWin32HandleInfoKHR const& ) const = default;
 #else
@@ -35308,19 +37610,30 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR;
     const void* pNext = {};
     const SECURITY_ATTRIBUTES* pAttributes = {};
     DWORD dwAccess = {};
     LPCWSTR name = {};
+
   };
   static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportFenceWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eExportFenceWin32HandleInfoKHR>
+  {
+    using Type = ExportFenceWin32HandleInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ExportMemoryAllocateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryAllocateInfo;
+
     VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT
       : handleTypes( handleTypes_ )
     {}
@@ -35354,6 +37667,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExportMemoryAllocateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportMemoryAllocateInfo*>( this );
@@ -35364,6 +37678,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportMemoryAllocateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExportMemoryAllocateInfo const& ) const = default;
 #else
@@ -35380,16 +37695,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportMemoryAllocateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes = {};
+
   };
   static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportMemoryAllocateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eExportMemoryAllocateInfo>
+  {
+    using Type = ExportMemoryAllocateInfo;
+  };
+
   struct ExportMemoryAllocateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryAllocateInfoNV;
+
     VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT
       : handleTypes( handleTypes_ )
     {}
@@ -35423,6 +37749,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExportMemoryAllocateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>( this );
@@ -35433,6 +37760,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportMemoryAllocateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExportMemoryAllocateInfoNV const& ) const = default;
 #else
@@ -35449,17 +37777,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleTypes = {};
+
   };
   static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportMemoryAllocateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eExportMemoryAllocateInfoNV>
+  {
+    using Type = ExportMemoryAllocateInfoNV;
+  };
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct ExportMemoryWin32HandleInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryWin32HandleInfoKHR;
+
     VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = {},
                                                          DWORD dwAccess_ = {},
                                                          LPCWSTR name_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -35509,6 +37848,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExportMemoryWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>( this );
@@ -35519,6 +37859,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExportMemoryWin32HandleInfoKHR const& ) const = default;
 #else
@@ -35537,20 +37878,31 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR;
     const void* pNext = {};
     const SECURITY_ATTRIBUTES* pAttributes = {};
     DWORD dwAccess = {};
     LPCWSTR name = {};
+
   };
   static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportMemoryWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eExportMemoryWin32HandleInfoKHR>
+  {
+    using Type = ExportMemoryWin32HandleInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct ExportMemoryWin32HandleInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryWin32HandleInfoNV;
+
     VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = {},
                                                         DWORD dwAccess_ = {} ) VULKAN_HPP_NOEXCEPT
       : pAttributes( pAttributes_ )
@@ -35592,6 +37944,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExportMemoryWin32HandleInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>( this );
@@ -35602,6 +37955,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExportMemoryWin32HandleInfoNV const& ) const = default;
 #else
@@ -35619,18 +37973,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV;
     const void* pNext = {};
     const SECURITY_ATTRIBUTES* pAttributes = {};
     DWORD dwAccess = {};
+
   };
   static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportMemoryWin32HandleInfoNV>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eExportMemoryWin32HandleInfoNV>
+  {
+    using Type = ExportMemoryWin32HandleInfoNV;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ExportSemaphoreCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportSemaphoreCreateInfo;
+
     VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT
       : handleTypes( handleTypes_ )
     {}
@@ -35664,6 +38029,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExportSemaphoreCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportSemaphoreCreateInfo*>( this );
@@ -35674,6 +38040,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportSemaphoreCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExportSemaphoreCreateInfo const& ) const = default;
 #else
@@ -35690,17 +38057,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportSemaphoreCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags handleTypes = {};
+
   };
   static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportSemaphoreCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eExportSemaphoreCreateInfo>
+  {
+    using Type = ExportSemaphoreCreateInfo;
+  };
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct ExportSemaphoreWin32HandleInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
+
     VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = {},
                                                             DWORD dwAccess_ = {},
                                                             LPCWSTR name_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -35750,6 +38128,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExportSemaphoreWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>( this );
@@ -35760,6 +38139,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExportSemaphoreWin32HandleInfoKHR const& ) const = default;
 #else
@@ -35778,19 +38158,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
     const void* pNext = {};
     const SECURITY_ATTRIBUTES* pAttributes = {};
     DWORD dwAccess = {};
     LPCWSTR name = {};
+
   };
   static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportSemaphoreWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eExportSemaphoreWin32HandleInfoKHR>
+  {
+    using Type = ExportSemaphoreWin32HandleInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ExtensionProperties
   {
+
     VULKAN_HPP_CONSTEXPR_14 ExtensionProperties( std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& extensionName_ = {},
                                                  uint32_t specVersion_ = {} ) VULKAN_HPP_NOEXCEPT
       : extensionName( extensionName_ )
@@ -35808,6 +38198,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExtensionProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExtensionProperties*>( this );
@@ -35818,6 +38209,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExtensionProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExtensionProperties const& ) const = default;
 #else
@@ -35833,15 +38225,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> extensionName = {};
     uint32_t specVersion = {};
+
   };
   static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExtensionProperties>::value, "struct wrapper is not a standard layout!" );
 
   struct ExternalMemoryProperties
   {
+
     VULKAN_HPP_CONSTEXPR ExternalMemoryProperties( VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags externalMemoryFeatures_ = {},
                                                    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes_ = {},
                                                    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags compatibleHandleTypes_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -35861,6 +38257,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExternalMemoryProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalMemoryProperties*>( this );
@@ -35871,6 +38268,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalMemoryProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExternalMemoryProperties const& ) const = default;
 #else
@@ -35887,16 +38285,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags externalMemoryFeatures = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags compatibleHandleTypes = {};
+
   };
   static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalMemoryProperties>::value, "struct wrapper is not a standard layout!" );
 
   struct ExternalBufferProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalBufferProperties;
+
     VULKAN_HPP_CONSTEXPR ExternalBufferProperties( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties externalMemoryProperties_ = {} ) VULKAN_HPP_NOEXCEPT
       : externalMemoryProperties( externalMemoryProperties_ )
     {}
@@ -35918,6 +38321,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExternalBufferProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalBufferProperties*>( this );
@@ -35928,6 +38332,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalBufferProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExternalBufferProperties const& ) const = default;
 #else
@@ -35944,16 +38349,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalBufferProperties;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryProperties externalMemoryProperties = {};
+
   };
   static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalBufferProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eExternalBufferProperties>
+  {
+    using Type = ExternalBufferProperties;
+  };
+
   struct ExternalFenceProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFenceProperties;
+
     VULKAN_HPP_CONSTEXPR ExternalFenceProperties( VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes_ = {},
                                                   VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags compatibleHandleTypes_ = {},
                                                   VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags externalFenceFeatures_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -35979,6 +38395,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExternalFenceProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalFenceProperties*>( this );
@@ -35989,6 +38406,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalFenceProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExternalFenceProperties const& ) const = default;
 #else
@@ -36007,19 +38425,30 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalFenceProperties;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes = {};
     VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags compatibleHandleTypes = {};
     VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags externalFenceFeatures = {};
+
   };
   static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalFenceProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eExternalFenceProperties>
+  {
+    using Type = ExternalFenceProperties;
+  };
+
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   struct ExternalFormatANDROID
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFormatANDROID;
+
     VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = {} ) VULKAN_HPP_NOEXCEPT
       : externalFormat( externalFormat_ )
     {}
@@ -36053,6 +38482,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExternalFormatANDROID const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalFormatANDROID*>( this );
@@ -36063,6 +38493,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalFormatANDROID*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExternalFormatANDROID const& ) const = default;
 #else
@@ -36079,17 +38510,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalFormatANDROID;
     void* pNext = {};
     uint64_t externalFormat = {};
+
   };
   static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalFormatANDROID>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eExternalFormatANDROID>
+  {
+    using Type = ExternalFormatANDROID;
+  };
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct ExternalImageFormatProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalImageFormatProperties;
+
     VULKAN_HPP_CONSTEXPR ExternalImageFormatProperties( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties externalMemoryProperties_ = {} ) VULKAN_HPP_NOEXCEPT
       : externalMemoryProperties( externalMemoryProperties_ )
     {}
@@ -36111,6 +38553,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExternalImageFormatProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalImageFormatProperties*>( this );
@@ -36121,6 +38564,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalImageFormatProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExternalImageFormatProperties const& ) const = default;
 #else
@@ -36137,16 +38581,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalImageFormatProperties;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryProperties externalMemoryProperties = {};
+
   };
   static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalImageFormatProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eExternalImageFormatProperties>
+  {
+    using Type = ExternalImageFormatProperties;
+  };
+
   struct ImageFormatProperties
   {
+
     VULKAN_HPP_CONSTEXPR ImageFormatProperties( VULKAN_HPP_NAMESPACE::Extent3D maxExtent_ = {},
                                                 uint32_t maxMipLevels_ = {},
                                                 uint32_t maxArrayLayers_ = {},
@@ -36170,6 +38624,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageFormatProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageFormatProperties*>( this );
@@ -36180,6 +38635,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageFormatProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageFormatProperties const& ) const = default;
 #else
@@ -36198,18 +38654,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Extent3D maxExtent = {};
     uint32_t maxMipLevels = {};
     uint32_t maxArrayLayers = {};
     VULKAN_HPP_NAMESPACE::SampleCountFlags sampleCounts = {};
     VULKAN_HPP_NAMESPACE::DeviceSize maxResourceSize = {};
+
   };
   static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageFormatProperties>::value, "struct wrapper is not a standard layout!" );
 
   struct ExternalImageFormatPropertiesNV
   {
+
     VULKAN_HPP_CONSTEXPR ExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties_ = {},
                                                           VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV externalMemoryFeatures_ = {},
                                                           VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes_ = {},
@@ -36231,6 +38691,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExternalImageFormatPropertiesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>( this );
@@ -36241,6 +38702,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalImageFormatPropertiesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExternalImageFormatPropertiesNV const& ) const = default;
 #else
@@ -36258,17 +38720,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV externalMemoryFeatures = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes = {};
+
   };
   static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalImageFormatPropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
   struct ExternalMemoryBufferCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryBufferCreateInfo;
+
     VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT
       : handleTypes( handleTypes_ )
     {}
@@ -36302,6 +38769,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExternalMemoryBufferCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>( this );
@@ -36312,6 +38780,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExternalMemoryBufferCreateInfo const& ) const = default;
 #else
@@ -36328,16 +38797,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalMemoryBufferCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes = {};
+
   };
   static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalMemoryBufferCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eExternalMemoryBufferCreateInfo>
+  {
+    using Type = ExternalMemoryBufferCreateInfo;
+  };
+
   struct ExternalMemoryImageCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryImageCreateInfo;
+
     VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT
       : handleTypes( handleTypes_ )
     {}
@@ -36371,6 +38851,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExternalMemoryImageCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalMemoryImageCreateInfo*>( this );
@@ -36381,6 +38862,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalMemoryImageCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExternalMemoryImageCreateInfo const& ) const = default;
 #else
@@ -36397,16 +38879,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalMemoryImageCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes = {};
+
   };
   static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalMemoryImageCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eExternalMemoryImageCreateInfo>
+  {
+    using Type = ExternalMemoryImageCreateInfo;
+  };
+
   struct ExternalMemoryImageCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryImageCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT
       : handleTypes( handleTypes_ )
     {}
@@ -36440,6 +38933,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExternalMemoryImageCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>( this );
@@ -36450,6 +38944,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExternalMemoryImageCreateInfoNV const& ) const = default;
 #else
@@ -36466,16 +38961,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleTypes = {};
+
   };
   static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalMemoryImageCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eExternalMemoryImageCreateInfoNV>
+  {
+    using Type = ExternalMemoryImageCreateInfoNV;
+  };
+
   struct ExternalSemaphoreProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalSemaphoreProperties;
+
     VULKAN_HPP_CONSTEXPR ExternalSemaphoreProperties( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes_ = {},
                                                       VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes_ = {},
                                                       VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -36501,6 +39007,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkExternalSemaphoreProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkExternalSemaphoreProperties*>( this );
@@ -36511,6 +39018,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalSemaphoreProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ExternalSemaphoreProperties const& ) const = default;
 #else
@@ -36529,18 +39037,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalSemaphoreProperties;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes = {};
     VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes = {};
     VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures = {};
+
   };
   static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalSemaphoreProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eExternalSemaphoreProperties>
+  {
+    using Type = ExternalSemaphoreProperties;
+  };
+
   struct FenceCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceCreateInfo;
+
     VULKAN_HPP_CONSTEXPR FenceCreateInfo( VULKAN_HPP_NAMESPACE::FenceCreateFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
     {}
@@ -36574,6 +39093,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkFenceCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFenceCreateInfo*>( this );
@@ -36584,6 +39104,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFenceCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( FenceCreateInfo const& ) const = default;
 #else
@@ -36600,16 +39121,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFenceCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::FenceCreateFlags flags = {};
+
   };
   static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FenceCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eFenceCreateInfo>
+  {
+    using Type = FenceCreateInfo;
+  };
+
   struct FenceGetFdInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceGetFdInfoKHR;
+
     VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {},
                                             VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
       : fence( fence_ )
@@ -36651,6 +39183,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkFenceGetFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFenceGetFdInfoKHR*>( this );
@@ -36661,6 +39194,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFenceGetFdInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( FenceGetFdInfoKHR const& ) const = default;
 #else
@@ -36678,18 +39212,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFenceGetFdInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Fence fence = {};
     VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd;
+
   };
   static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FenceGetFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eFenceGetFdInfoKHR>
+  {
+    using Type = FenceGetFdInfoKHR;
+  };
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct FenceGetWin32HandleInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceGetWin32HandleInfoKHR;
+
     VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {},
                                                      VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
       : fence( fence_ )
@@ -36731,6 +39276,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkFenceGetWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( this );
@@ -36741,6 +39287,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( FenceGetWin32HandleInfoKHR const& ) const = default;
 #else
@@ -36758,18 +39305,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Fence fence = {};
     VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd;
+
   };
   static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FenceGetWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eFenceGetWin32HandleInfoKHR>
+  {
+    using Type = FenceGetWin32HandleInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct FilterCubicImageViewImageFormatPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR FilterCubicImageViewImageFormatPropertiesEXT( VULKAN_HPP_NAMESPACE::Bool32 filterCubic_ = {},
                                                                        VULKAN_HPP_NAMESPACE::Bool32 filterCubicMinmax_ = {} ) VULKAN_HPP_NOEXCEPT
       : filterCubic( filterCubic_ )
@@ -36793,6 +39351,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkFilterCubicImageViewImageFormatPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>( this );
@@ -36803,6 +39362,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( FilterCubicImageViewImageFormatPropertiesEXT const& ) const = default;
 #else
@@ -36820,17 +39380,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 filterCubic = {};
     VULKAN_HPP_NAMESPACE::Bool32 filterCubicMinmax = {};
+
   };
   static_assert( sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) == sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FilterCubicImageViewImageFormatPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eFilterCubicImageViewImageFormatPropertiesEXT>
+  {
+    using Type = FilterCubicImageViewImageFormatPropertiesEXT;
+  };
+
   struct FormatProperties
   {
+
     VULKAN_HPP_CONSTEXPR FormatProperties( VULKAN_HPP_NAMESPACE::FormatFeatureFlags linearTilingFeatures_ = {},
                                            VULKAN_HPP_NAMESPACE::FormatFeatureFlags optimalTilingFeatures_ = {},
                                            VULKAN_HPP_NAMESPACE::FormatFeatureFlags bufferFeatures_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -36850,6 +39420,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkFormatProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFormatProperties*>( this );
@@ -36860,6 +39431,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFormatProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( FormatProperties const& ) const = default;
 #else
@@ -36876,16 +39448,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::FormatFeatureFlags linearTilingFeatures = {};
     VULKAN_HPP_NAMESPACE::FormatFeatureFlags optimalTilingFeatures = {};
     VULKAN_HPP_NAMESPACE::FormatFeatureFlags bufferFeatures = {};
+
   };
   static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FormatProperties>::value, "struct wrapper is not a standard layout!" );
 
   struct FormatProperties2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFormatProperties2;
+
     VULKAN_HPP_CONSTEXPR FormatProperties2( VULKAN_HPP_NAMESPACE::FormatProperties formatProperties_ = {} ) VULKAN_HPP_NOEXCEPT
       : formatProperties( formatProperties_ )
     {}
@@ -36907,6 +39484,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkFormatProperties2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFormatProperties2*>( this );
@@ -36917,6 +39495,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFormatProperties2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( FormatProperties2 const& ) const = default;
 #else
@@ -36933,16 +39512,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFormatProperties2;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::FormatProperties formatProperties = {};
+
   };
   static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FormatProperties2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eFormatProperties2>
+  {
+    using Type = FormatProperties2;
+  };
+
   struct FramebufferAttachmentImageInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferAttachmentImageInfo;
+
     VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfo( VULKAN_HPP_NAMESPACE::ImageCreateFlags flags_ = {},
                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags usage_ = {},
                                                          uint32_t width_ = {},
@@ -37024,6 +39614,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkFramebufferAttachmentImageInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFramebufferAttachmentImageInfo*>( this );
@@ -37034,6 +39625,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFramebufferAttachmentImageInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( FramebufferAttachmentImageInfo const& ) const = default;
 #else
@@ -37056,6 +39648,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFramebufferAttachmentImageInfo;
     const void* pNext = {};
@@ -37066,12 +39660,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t layerCount = {};
     uint32_t viewFormatCount = {};
     const VULKAN_HPP_NAMESPACE::Format* pViewFormats = {};
+
   };
   static_assert( sizeof( FramebufferAttachmentImageInfo ) == sizeof( VkFramebufferAttachmentImageInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FramebufferAttachmentImageInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eFramebufferAttachmentImageInfo>
+  {
+    using Type = FramebufferAttachmentImageInfo;
+  };
+
   struct FramebufferAttachmentsCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferAttachmentsCreateInfo;
+
     VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfo( uint32_t attachmentImageInfoCount_ = {},
                                                            const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo* pAttachmentImageInfos_ = {} ) VULKAN_HPP_NOEXCEPT
       : attachmentImageInfoCount( attachmentImageInfoCount_ )
@@ -37113,6 +39716,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkFramebufferAttachmentsCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>( this );
@@ -37123,6 +39727,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( FramebufferAttachmentsCreateInfo const& ) const = default;
 #else
@@ -37140,17 +39745,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFramebufferAttachmentsCreateInfo;
     const void* pNext = {};
     uint32_t attachmentImageInfoCount = {};
     const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo* pAttachmentImageInfos = {};
+
   };
   static_assert( sizeof( FramebufferAttachmentsCreateInfo ) == sizeof( VkFramebufferAttachmentsCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FramebufferAttachmentsCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eFramebufferAttachmentsCreateInfo>
+  {
+    using Type = FramebufferAttachmentsCreateInfo;
+  };
+
   struct FramebufferCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferCreateInfo;
+
     VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( VULKAN_HPP_NAMESPACE::FramebufferCreateFlags flags_ = {},
                                                 VULKAN_HPP_NAMESPACE::RenderPass renderPass_ = {},
                                                 uint32_t attachmentCount_ = {},
@@ -37232,6 +39848,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkFramebufferCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFramebufferCreateInfo*>( this );
@@ -37242,6 +39859,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFramebufferCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( FramebufferCreateInfo const& ) const = default;
 #else
@@ -37264,6 +39882,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFramebufferCreateInfo;
     const void* pNext = {};
@@ -37274,12 +39894,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t width = {};
     uint32_t height = {};
     uint32_t layers = {};
+
   };
   static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FramebufferCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eFramebufferCreateInfo>
+  {
+    using Type = FramebufferCreateInfo;
+  };
+
   struct FramebufferMixedSamplesCombinationNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferMixedSamplesCombinationNV;
+
     VULKAN_HPP_CONSTEXPR FramebufferMixedSamplesCombinationNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode_ = VULKAN_HPP_NAMESPACE::CoverageReductionModeNV::eMerge,
                                                                VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1,
                                                                VULKAN_HPP_NAMESPACE::SampleCountFlags depthStencilSamples_ = {},
@@ -37307,6 +39936,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkFramebufferMixedSamplesCombinationNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkFramebufferMixedSamplesCombinationNV*>( this );
@@ -37317,6 +39947,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( FramebufferMixedSamplesCombinationNV const& ) const = default;
 #else
@@ -37336,6 +39967,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV;
     void* pNext = {};
@@ -37343,12 +39976,20 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1;
     VULKAN_HPP_NAMESPACE::SampleCountFlags depthStencilSamples = {};
     VULKAN_HPP_NAMESPACE::SampleCountFlags colorSamples = {};
+
   };
   static_assert( sizeof( FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FramebufferMixedSamplesCombinationNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eFramebufferMixedSamplesCombinationNV>
+  {
+    using Type = FramebufferMixedSamplesCombinationNV;
+  };
+
   struct IndirectCommandsStreamNV
   {
+
     VULKAN_HPP_CONSTEXPR IndirectCommandsStreamNV( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {},
                                                    VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {} ) VULKAN_HPP_NOEXCEPT
       : buffer( buffer_ )
@@ -37378,6 +40019,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkIndirectCommandsStreamNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkIndirectCommandsStreamNV*>( this );
@@ -37388,6 +40030,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkIndirectCommandsStreamNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( IndirectCommandsStreamNV const& ) const = default;
 #else
@@ -37403,15 +40046,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Buffer buffer = {};
     VULKAN_HPP_NAMESPACE::DeviceSize offset = {};
+
   };
   static_assert( sizeof( IndirectCommandsStreamNV ) == sizeof( VkIndirectCommandsStreamNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<IndirectCommandsStreamNV>::value, "struct wrapper is not a standard layout!" );
 
   struct GeneratedCommandsInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsInfoNV;
+
     VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics,
                                                   VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {},
                                                   VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout_ = {},
@@ -37541,6 +40189,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkGeneratedCommandsInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeneratedCommandsInfoNV*>( this );
@@ -37551,6 +40200,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeneratedCommandsInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( GeneratedCommandsInfoNV const& ) const = default;
 #else
@@ -37579,6 +40229,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGeneratedCommandsInfoNV;
     const void* pNext = {};
@@ -37595,12 +40247,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeviceSize sequencesCountOffset = {};
     VULKAN_HPP_NAMESPACE::Buffer sequencesIndexBuffer = {};
     VULKAN_HPP_NAMESPACE::DeviceSize sequencesIndexOffset = {};
+
   };
   static_assert( sizeof( GeneratedCommandsInfoNV ) == sizeof( VkGeneratedCommandsInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GeneratedCommandsInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eGeneratedCommandsInfoNV>
+  {
+    using Type = GeneratedCommandsInfoNV;
+  };
+
   struct GeneratedCommandsMemoryRequirementsInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsMemoryRequirementsInfoNV;
+
     VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics,
                                                                     VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {},
                                                                     VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout_ = {},
@@ -37658,6 +40319,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkGeneratedCommandsMemoryRequirementsInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV*>( this );
@@ -37668,6 +40330,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( GeneratedCommandsMemoryRequirementsInfoNV const& ) const = default;
 #else
@@ -37687,6 +40350,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGeneratedCommandsMemoryRequirementsInfoNV;
     const void* pNext = {};
@@ -37694,12 +40359,20 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Pipeline pipeline = {};
     VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout = {};
     uint32_t maxSequencesCount = {};
+
   };
   static_assert( sizeof( GeneratedCommandsMemoryRequirementsInfoNV ) == sizeof( VkGeneratedCommandsMemoryRequirementsInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GeneratedCommandsMemoryRequirementsInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eGeneratedCommandsMemoryRequirementsInfoNV>
+  {
+    using Type = GeneratedCommandsMemoryRequirementsInfoNV;
+  };
+
   struct VertexInputBindingDescription
   {
+
     VULKAN_HPP_CONSTEXPR VertexInputBindingDescription( uint32_t binding_ = {},
                                                         uint32_t stride_ = {},
                                                         VULKAN_HPP_NAMESPACE::VertexInputRate inputRate_ = VULKAN_HPP_NAMESPACE::VertexInputRate::eVertex ) VULKAN_HPP_NOEXCEPT
@@ -37737,6 +40410,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkVertexInputBindingDescription const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVertexInputBindingDescription*>( this );
@@ -37747,6 +40421,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVertexInputBindingDescription*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( VertexInputBindingDescription const& ) const = default;
 #else
@@ -37763,16 +40438,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t binding = {};
     uint32_t stride = {};
     VULKAN_HPP_NAMESPACE::VertexInputRate inputRate = VULKAN_HPP_NAMESPACE::VertexInputRate::eVertex;
+
   };
   static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<VertexInputBindingDescription>::value, "struct wrapper is not a standard layout!" );
 
   struct VertexInputAttributeDescription
   {
+
     VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription( uint32_t location_ = {},
                                                           uint32_t binding_ = {},
                                                           VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
@@ -37818,6 +40497,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkVertexInputAttributeDescription const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVertexInputAttributeDescription*>( this );
@@ -37828,6 +40508,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVertexInputAttributeDescription*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( VertexInputAttributeDescription const& ) const = default;
 #else
@@ -37845,17 +40526,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t location = {};
     uint32_t binding = {};
     VULKAN_HPP_NAMESPACE::Format format = VULKAN_HPP_NAMESPACE::Format::eUndefined;
     uint32_t offset = {};
+
   };
   static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<VertexInputAttributeDescription>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineVertexInputStateCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineVertexInputStateCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags flags_ = {},
                                                              uint32_t vertexBindingDescriptionCount_ = {},
                                                              const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription* pVertexBindingDescriptions_ = {},
@@ -37921,6 +40607,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineVertexInputStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>( this );
@@ -37931,6 +40618,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineVertexInputStateCreateInfo const& ) const = default;
 #else
@@ -37951,6 +40639,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo;
     const void* pNext = {};
@@ -37959,12 +40649,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription* pVertexBindingDescriptions = {};
     uint32_t vertexAttributeDescriptionCount = {};
     const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription* pVertexAttributeDescriptions = {};
+
   };
   static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineVertexInputStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineVertexInputStateCreateInfo>
+  {
+    using Type = PipelineVertexInputStateCreateInfo;
+  };
+
   struct PipelineInputAssemblyStateCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineInputAssemblyStateCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags flags_ = {},
                                                                VULKAN_HPP_NAMESPACE::PrimitiveTopology topology_ = VULKAN_HPP_NAMESPACE::PrimitiveTopology::ePointList,
                                                                VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -38014,6 +40713,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineInputAssemblyStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>( this );
@@ -38024,6 +40724,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineInputAssemblyStateCreateInfo const& ) const = default;
 #else
@@ -38042,18 +40743,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags flags = {};
     VULKAN_HPP_NAMESPACE::PrimitiveTopology topology = VULKAN_HPP_NAMESPACE::PrimitiveTopology::ePointList;
     VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable = {};
+
   };
   static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineInputAssemblyStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineInputAssemblyStateCreateInfo>
+  {
+    using Type = PipelineInputAssemblyStateCreateInfo;
+  };
+
   struct PipelineTessellationStateCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineTessellationStateCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags flags_ = {},
                                                               uint32_t patchControlPoints_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -38095,6 +40807,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineTessellationStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>( this );
@@ -38105,6 +40818,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineTessellationStateCreateInfo const& ) const = default;
 #else
@@ -38122,17 +40836,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineTessellationStateCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags flags = {};
     uint32_t patchControlPoints = {};
+
   };
   static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineTessellationStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineTessellationStateCreateInfo>
+  {
+    using Type = PipelineTessellationStateCreateInfo;
+  };
+
   struct Viewport
   {
+
     VULKAN_HPP_CONSTEXPR Viewport( float x_ = {},
                                    float y_ = {},
                                    float width_ = {},
@@ -38194,6 +40918,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkViewport const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkViewport*>( this );
@@ -38204,6 +40929,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkViewport*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( Viewport const& ) const = default;
 #else
@@ -38223,6 +40949,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     float x = {};
     float y = {};
@@ -38230,12 +40958,15 @@ namespace VULKAN_HPP_NAMESPACE
     float height = {};
     float minDepth = {};
     float maxDepth = {};
+
   };
   static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Viewport>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineViewportStateCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportStateCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags flags_ = {},
                                                           uint32_t viewportCount_ = {},
                                                           const VULKAN_HPP_NAMESPACE::Viewport* pViewports_ = {},
@@ -38301,6 +41032,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineViewportStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>( this );
@@ -38311,6 +41043,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportStateCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineViewportStateCreateInfo const& ) const = default;
 #else
@@ -38331,6 +41064,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportStateCreateInfo;
     const void* pNext = {};
@@ -38339,12 +41074,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::Viewport* pViewports = {};
     uint32_t scissorCount = {};
     const VULKAN_HPP_NAMESPACE::Rect2D* pScissors = {};
+
   };
   static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineViewportStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineViewportStateCreateInfo>
+  {
+    using Type = PipelineViewportStateCreateInfo;
+  };
+
   struct PipelineRasterizationStateCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags flags_ = {},
                                                                VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable_ = {},
                                                                VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable_ = {},
@@ -38458,6 +41202,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineRasterizationStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>( this );
@@ -38468,6 +41213,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineRasterizationStateCreateInfo const& ) const = default;
 #else
@@ -38494,6 +41240,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo;
     const void* pNext = {};
@@ -38508,12 +41256,21 @@ namespace VULKAN_HPP_NAMESPACE
     float depthBiasClamp = {};
     float depthBiasSlopeFactor = {};
     float lineWidth = {};
+
   };
   static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineRasterizationStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineRasterizationStateCreateInfo>
+  {
+    using Type = PipelineRasterizationStateCreateInfo;
+  };
+
   struct PipelineMultisampleStateCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineMultisampleStateCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags flags_ = {},
                                                              VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1,
                                                              VULKAN_HPP_NAMESPACE::Bool32 sampleShadingEnable_ = {},
@@ -38595,6 +41352,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineMultisampleStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>( this );
@@ -38605,6 +41363,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineMultisampleStateCreateInfo const& ) const = default;
 #else
@@ -38627,6 +41386,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
     const void* pNext = {};
@@ -38637,12 +41398,20 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::SampleMask* pSampleMask = {};
     VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable = {};
     VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable = {};
+
   };
   static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineMultisampleStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineMultisampleStateCreateInfo>
+  {
+    using Type = PipelineMultisampleStateCreateInfo;
+  };
+
   struct StencilOpState
   {
+
     VULKAN_HPP_CONSTEXPR StencilOpState( VULKAN_HPP_NAMESPACE::StencilOp failOp_ = VULKAN_HPP_NAMESPACE::StencilOp::eKeep,
                                          VULKAN_HPP_NAMESPACE::StencilOp passOp_ = VULKAN_HPP_NAMESPACE::StencilOp::eKeep,
                                          VULKAN_HPP_NAMESPACE::StencilOp depthFailOp_ = VULKAN_HPP_NAMESPACE::StencilOp::eKeep,
@@ -38712,6 +41481,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkStencilOpState const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkStencilOpState*>( this );
@@ -38722,6 +41492,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkStencilOpState*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( StencilOpState const& ) const = default;
 #else
@@ -38742,6 +41513,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::StencilOp failOp = VULKAN_HPP_NAMESPACE::StencilOp::eKeep;
     VULKAN_HPP_NAMESPACE::StencilOp passOp = VULKAN_HPP_NAMESPACE::StencilOp::eKeep;
@@ -38750,12 +41523,15 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t compareMask = {};
     uint32_t writeMask = {};
     uint32_t reference = {};
+
   };
   static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<StencilOpState>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineDepthStencilStateCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDepthStencilStateCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags flags_ = {},
                                                               VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable_ = {},
                                                               VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable_ = {},
@@ -38837,13 +41613,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo & setFront( VULKAN_HPP_NAMESPACE::StencilOpState front_ ) VULKAN_HPP_NOEXCEPT
+    PipelineDepthStencilStateCreateInfo & setFront( VULKAN_HPP_NAMESPACE::StencilOpState const & front_ ) VULKAN_HPP_NOEXCEPT
     {
       front = front_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo & setBack( VULKAN_HPP_NAMESPACE::StencilOpState back_ ) VULKAN_HPP_NOEXCEPT
+    PipelineDepthStencilStateCreateInfo & setBack( VULKAN_HPP_NAMESPACE::StencilOpState const & back_ ) VULKAN_HPP_NOEXCEPT
     {
       back = back_;
       return *this;
@@ -38861,6 +41637,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineDepthStencilStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>( this );
@@ -38871,6 +41648,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineDepthStencilStateCreateInfo const& ) const = default;
 #else
@@ -38896,6 +41674,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo;
     const void* pNext = {};
@@ -38909,12 +41689,20 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::StencilOpState back = {};
     float minDepthBounds = {};
     float maxDepthBounds = {};
+
   };
   static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineDepthStencilStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineDepthStencilStateCreateInfo>
+  {
+    using Type = PipelineDepthStencilStateCreateInfo;
+  };
+
   struct PipelineColorBlendAttachmentState
   {
+
     VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( VULKAN_HPP_NAMESPACE::Bool32 blendEnable_ = {},
                                                             VULKAN_HPP_NAMESPACE::BlendFactor srcColorBlendFactor_ = VULKAN_HPP_NAMESPACE::BlendFactor::eZero,
                                                             VULKAN_HPP_NAMESPACE::BlendFactor dstColorBlendFactor_ = VULKAN_HPP_NAMESPACE::BlendFactor::eZero,
@@ -38992,6 +41780,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineColorBlendAttachmentState const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>( this );
@@ -39002,6 +41791,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineColorBlendAttachmentState*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineColorBlendAttachmentState const& ) const = default;
 #else
@@ -39023,6 +41813,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Bool32 blendEnable = {};
     VULKAN_HPP_NAMESPACE::BlendFactor srcColorBlendFactor = VULKAN_HPP_NAMESPACE::BlendFactor::eZero;
@@ -39032,12 +41824,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::BlendFactor dstAlphaBlendFactor = VULKAN_HPP_NAMESPACE::BlendFactor::eZero;
     VULKAN_HPP_NAMESPACE::BlendOp alphaBlendOp = VULKAN_HPP_NAMESPACE::BlendOp::eAdd;
     VULKAN_HPP_NAMESPACE::ColorComponentFlags colorWriteMask = {};
+
   };
   static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineColorBlendAttachmentState>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineColorBlendStateCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineColorBlendStateCreateInfo;
+
     VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags flags_ = {},
                                                                VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable_ = {},
                                                                VULKAN_HPP_NAMESPACE::LogicOp logicOp_ = VULKAN_HPP_NAMESPACE::LogicOp::eClear,
@@ -39111,6 +41906,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineColorBlendStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>( this );
@@ -39121,6 +41917,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineColorBlendStateCreateInfo const& ) const = default;
 #else
@@ -39142,6 +41939,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
     const void* pNext = {};
@@ -39151,12 +41950,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t attachmentCount = {};
     const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState* pAttachments = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> blendConstants = {};
+
   };
   static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineColorBlendStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineColorBlendStateCreateInfo>
+  {
+    using Type = PipelineColorBlendStateCreateInfo;
+  };
+
   struct PipelineDynamicStateCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDynamicStateCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags flags_ = {},
                                                          uint32_t dynamicStateCount_ = {},
                                                          const VULKAN_HPP_NAMESPACE::DynamicState* pDynamicStates_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -39206,6 +42014,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineDynamicStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>( this );
@@ -39216,6 +42025,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineDynamicStateCreateInfo const& ) const = default;
 #else
@@ -39234,18 +42044,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags flags = {};
     uint32_t dynamicStateCount = {};
     const VULKAN_HPP_NAMESPACE::DynamicState* pDynamicStates = {};
+
   };
   static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineDynamicStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineDynamicStateCreateInfo>
+  {
+    using Type = PipelineDynamicStateCreateInfo;
+  };
+
   struct GraphicsPipelineCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsPipelineCreateInfo;
+
     VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {},
                                                         uint32_t stageCount_ = {},
                                                         const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages_ = {},
@@ -39407,6 +42228,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkGraphicsPipelineCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( this );
@@ -39417,6 +42239,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGraphicsPipelineCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( GraphicsPipelineCreateInfo const& ) const = default;
 #else
@@ -39449,6 +42272,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
     const void* pNext = {};
@@ -39469,12 +42294,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t subpass = {};
     VULKAN_HPP_NAMESPACE::Pipeline basePipelineHandle = {};
     int32_t basePipelineIndex = {};
+
   };
   static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GraphicsPipelineCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eGraphicsPipelineCreateInfo>
+  {
+    using Type = GraphicsPipelineCreateInfo;
+  };
+
   struct GraphicsShaderGroupCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsShaderGroupCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR GraphicsShaderGroupCreateInfoNV( uint32_t stageCount_ = {},
                                                           const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages_ = {},
                                                           const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo* pVertexInputState_ = {},
@@ -39532,6 +42366,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkGraphicsShaderGroupCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGraphicsShaderGroupCreateInfoNV*>( this );
@@ -39542,6 +42377,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGraphicsShaderGroupCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( GraphicsShaderGroupCreateInfoNV const& ) const = default;
 #else
@@ -39561,6 +42397,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGraphicsShaderGroupCreateInfoNV;
     const void* pNext = {};
@@ -39568,12 +42406,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages = {};
     const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo* pVertexInputState = {};
     const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo* pTessellationState = {};
+
   };
   static_assert( sizeof( GraphicsShaderGroupCreateInfoNV ) == sizeof( VkGraphicsShaderGroupCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GraphicsShaderGroupCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eGraphicsShaderGroupCreateInfoNV>
+  {
+    using Type = GraphicsShaderGroupCreateInfoNV;
+  };
+
   struct GraphicsPipelineShaderGroupsCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR GraphicsPipelineShaderGroupsCreateInfoNV( uint32_t groupCount_ = {},
                                                                    const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV* pGroups_ = {},
                                                                    uint32_t pipelineCount_ = {},
@@ -39631,6 +42478,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkGraphicsPipelineShaderGroupsCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>( this );
@@ -39641,6 +42489,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( GraphicsPipelineShaderGroupsCreateInfoNV const& ) const = default;
 #else
@@ -39660,6 +42509,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV;
     const void* pNext = {};
@@ -39667,12 +42518,20 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV* pGroups = {};
     uint32_t pipelineCount = {};
     const VULKAN_HPP_NAMESPACE::Pipeline* pPipelines = {};
+
   };
   static_assert( sizeof( GraphicsPipelineShaderGroupsCreateInfoNV ) == sizeof( VkGraphicsPipelineShaderGroupsCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GraphicsPipelineShaderGroupsCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV>
+  {
+    using Type = GraphicsPipelineShaderGroupsCreateInfoNV;
+  };
+
   struct XYColorEXT
   {
+
     VULKAN_HPP_CONSTEXPR XYColorEXT( float x_ = {},
                                      float y_ = {} ) VULKAN_HPP_NOEXCEPT
       : x( x_ )
@@ -39702,6 +42561,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkXYColorEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkXYColorEXT*>( this );
@@ -39712,6 +42572,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkXYColorEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( XYColorEXT const& ) const = default;
 #else
@@ -39727,15 +42588,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     float x = {};
     float y = {};
+
   };
   static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<XYColorEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct HdrMetadataEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHdrMetadataEXT;
+
     VULKAN_HPP_CONSTEXPR HdrMetadataEXT( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryRed_ = {},
                                          VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryGreen_ = {},
                                          VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryBlue_ = {},
@@ -39777,25 +42643,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    HdrMetadataEXT & setDisplayPrimaryRed( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryRed_ ) VULKAN_HPP_NOEXCEPT
+    HdrMetadataEXT & setDisplayPrimaryRed( VULKAN_HPP_NAMESPACE::XYColorEXT const & displayPrimaryRed_ ) VULKAN_HPP_NOEXCEPT
     {
       displayPrimaryRed = displayPrimaryRed_;
       return *this;
     }
 
-    HdrMetadataEXT & setDisplayPrimaryGreen( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryGreen_ ) VULKAN_HPP_NOEXCEPT
+    HdrMetadataEXT & setDisplayPrimaryGreen( VULKAN_HPP_NAMESPACE::XYColorEXT const & displayPrimaryGreen_ ) VULKAN_HPP_NOEXCEPT
     {
       displayPrimaryGreen = displayPrimaryGreen_;
       return *this;
     }
 
-    HdrMetadataEXT & setDisplayPrimaryBlue( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryBlue_ ) VULKAN_HPP_NOEXCEPT
+    HdrMetadataEXT & setDisplayPrimaryBlue( VULKAN_HPP_NAMESPACE::XYColorEXT const & displayPrimaryBlue_ ) VULKAN_HPP_NOEXCEPT
     {
       displayPrimaryBlue = displayPrimaryBlue_;
       return *this;
     }
 
-    HdrMetadataEXT & setWhitePoint( VULKAN_HPP_NAMESPACE::XYColorEXT whitePoint_ ) VULKAN_HPP_NOEXCEPT
+    HdrMetadataEXT & setWhitePoint( VULKAN_HPP_NAMESPACE::XYColorEXT const & whitePoint_ ) VULKAN_HPP_NOEXCEPT
     {
       whitePoint = whitePoint_;
       return *this;
@@ -39825,6 +42691,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkHdrMetadataEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkHdrMetadataEXT*>( this );
@@ -39835,6 +42702,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkHdrMetadataEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( HdrMetadataEXT const& ) const = default;
 #else
@@ -39858,6 +42726,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eHdrMetadataEXT;
     const void* pNext = {};
@@ -39869,12 +42739,21 @@ namespace VULKAN_HPP_NAMESPACE
     float minLuminance = {};
     float maxContentLightLevel = {};
     float maxFrameAverageLightLevel = {};
+
   };
   static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<HdrMetadataEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eHdrMetadataEXT>
+  {
+    using Type = HdrMetadataEXT;
+  };
+
   struct HeadlessSurfaceCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHeadlessSurfaceCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT flags_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
     {}
@@ -39908,6 +42787,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkHeadlessSurfaceCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>( this );
@@ -39918,6 +42798,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( HeadlessSurfaceCreateInfoEXT const& ) const = default;
 #else
@@ -39934,17 +42815,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT flags = {};
+
   };
   static_assert( sizeof( HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<HeadlessSurfaceCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eHeadlessSurfaceCreateInfoEXT>
+  {
+    using Type = HeadlessSurfaceCreateInfoEXT;
+  };
+
 #ifdef VK_USE_PLATFORM_IOS_MVK
   struct IOSSurfaceCreateInfoMVK
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIosSurfaceCreateInfoMVK;
+
     VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK flags_ = {},
                                                   const void* pView_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -39986,6 +42878,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkIOSSurfaceCreateInfoMVK const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( this );
@@ -39996,6 +42889,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( IOSSurfaceCreateInfoMVK const& ) const = default;
 #else
@@ -40013,18 +42907,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eIosSurfaceCreateInfoMVK;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK flags = {};
     const void* pView = {};
+
   };
   static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<IOSSurfaceCreateInfoMVK>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eIosSurfaceCreateInfoMVK>
+  {
+    using Type = IOSSurfaceCreateInfoMVK;
+  };
 #endif /*VK_USE_PLATFORM_IOS_MVK*/
 
   struct ImageBlit
   {
+
     VULKAN_HPP_CONSTEXPR_14 ImageBlit( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ = {},
                                        std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> const& srcOffsets_ = {},
                                        VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ = {},
@@ -40046,30 +42950,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageBlit & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ ) VULKAN_HPP_NOEXCEPT
+    ImageBlit & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
       srcSubresource = srcSubresource_;
       return *this;
     }
 
-    ImageBlit & setSrcOffsets( std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> srcOffsets_ ) VULKAN_HPP_NOEXCEPT
+    ImageBlit & setSrcOffsets( std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> const & srcOffsets_ ) VULKAN_HPP_NOEXCEPT
     {
       srcOffsets = srcOffsets_;
       return *this;
     }
 
-    ImageBlit & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ ) VULKAN_HPP_NOEXCEPT
+    ImageBlit & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & dstSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
       dstSubresource = dstSubresource_;
       return *this;
     }
 
-    ImageBlit & setDstOffsets( std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> dstOffsets_ ) VULKAN_HPP_NOEXCEPT
+    ImageBlit & setDstOffsets( std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> const & dstOffsets_ ) VULKAN_HPP_NOEXCEPT
     {
       dstOffsets = dstOffsets_;
       return *this;
     }
 
+
     operator VkImageBlit const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageBlit*>( this );
@@ -40080,6 +42985,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageBlit*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageBlit const& ) const = default;
 #else
@@ -40097,17 +43003,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> srcOffsets = {};
     VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> dstOffsets = {};
+
   };
   static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageBlit>::value, "struct wrapper is not a standard layout!" );
 
   struct ImageCopy
   {
+
     VULKAN_HPP_CONSTEXPR ImageCopy( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ = {},
                                     VULKAN_HPP_NAMESPACE::Offset3D srcOffset_ = {},
                                     VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ = {},
@@ -40131,36 +43041,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageCopy & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ ) VULKAN_HPP_NOEXCEPT
+    ImageCopy & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
       srcSubresource = srcSubresource_;
       return *this;
     }
 
-    ImageCopy & setSrcOffset( VULKAN_HPP_NAMESPACE::Offset3D srcOffset_ ) VULKAN_HPP_NOEXCEPT
+    ImageCopy & setSrcOffset( VULKAN_HPP_NAMESPACE::Offset3D const & srcOffset_ ) VULKAN_HPP_NOEXCEPT
     {
       srcOffset = srcOffset_;
       return *this;
     }
 
-    ImageCopy & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ ) VULKAN_HPP_NOEXCEPT
+    ImageCopy & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & dstSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
       dstSubresource = dstSubresource_;
       return *this;
     }
 
-    ImageCopy & setDstOffset( VULKAN_HPP_NAMESPACE::Offset3D dstOffset_ ) VULKAN_HPP_NOEXCEPT
+    ImageCopy & setDstOffset( VULKAN_HPP_NAMESPACE::Offset3D const & dstOffset_ ) VULKAN_HPP_NOEXCEPT
     {
       dstOffset = dstOffset_;
       return *this;
     }
 
-    ImageCopy & setExtent( VULKAN_HPP_NAMESPACE::Extent3D extent_ ) VULKAN_HPP_NOEXCEPT
+    ImageCopy & setExtent( VULKAN_HPP_NAMESPACE::Extent3D const & extent_ ) VULKAN_HPP_NOEXCEPT
     {
       extent = extent_;
       return *this;
     }
 
+
     operator VkImageCopy const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageCopy*>( this );
@@ -40171,6 +43082,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageCopy*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageCopy const& ) const = default;
 #else
@@ -40189,18 +43101,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource = {};
     VULKAN_HPP_NAMESPACE::Offset3D srcOffset = {};
     VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource = {};
     VULKAN_HPP_NAMESPACE::Offset3D dstOffset = {};
     VULKAN_HPP_NAMESPACE::Extent3D extent = {};
+
   };
   static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageCopy>::value, "struct wrapper is not a standard layout!" );
 
   struct ImageCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCreateInfo;
+
     VULKAN_HPP_CONSTEXPR ImageCreateInfo( VULKAN_HPP_NAMESPACE::ImageCreateFlags flags_ = {},
                                           VULKAN_HPP_NAMESPACE::ImageType imageType_ = VULKAN_HPP_NAMESPACE::ImageType::e1D,
                                           VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
@@ -40270,7 +43187,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageCreateInfo & setExtent( VULKAN_HPP_NAMESPACE::Extent3D extent_ ) VULKAN_HPP_NOEXCEPT
+    ImageCreateInfo & setExtent( VULKAN_HPP_NAMESPACE::Extent3D const & extent_ ) VULKAN_HPP_NOEXCEPT
     {
       extent = extent_;
       return *this;
@@ -40330,6 +43247,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageCreateInfo*>( this );
@@ -40340,6 +43258,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageCreateInfo const& ) const = default;
 #else
@@ -40368,6 +43287,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageCreateInfo;
     const void* pNext = {};
@@ -40384,12 +43305,20 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t queueFamilyIndexCount = {};
     const uint32_t* pQueueFamilyIndices = {};
     VULKAN_HPP_NAMESPACE::ImageLayout initialLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
+
   };
   static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageCreateInfo>
+  {
+    using Type = ImageCreateInfo;
+  };
+
   struct SubresourceLayout
   {
+
     VULKAN_HPP_CONSTEXPR SubresourceLayout( VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {},
                                             VULKAN_HPP_NAMESPACE::DeviceSize size_ = {},
                                             VULKAN_HPP_NAMESPACE::DeviceSize rowPitch_ = {},
@@ -40413,6 +43342,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSubresourceLayout const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubresourceLayout*>( this );
@@ -40423,6 +43353,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubresourceLayout*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SubresourceLayout const& ) const = default;
 #else
@@ -40441,18 +43372,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DeviceSize offset = {};
     VULKAN_HPP_NAMESPACE::DeviceSize size = {};
     VULKAN_HPP_NAMESPACE::DeviceSize rowPitch = {};
     VULKAN_HPP_NAMESPACE::DeviceSize arrayPitch = {};
     VULKAN_HPP_NAMESPACE::DeviceSize depthPitch = {};
+
   };
   static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SubresourceLayout>::value, "struct wrapper is not a standard layout!" );
 
   struct ImageDrmFormatModifierExplicitCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = {},
                                                                       uint32_t drmFormatModifierPlaneCount_ = {},
                                                                       const VULKAN_HPP_NAMESPACE::SubresourceLayout* pPlaneLayouts_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -40502,6 +43438,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageDrmFormatModifierExplicitCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>( this );
@@ -40512,6 +43449,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageDrmFormatModifierExplicitCreateInfoEXT const& ) const = default;
 #else
@@ -40530,18 +43468,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT;
     const void* pNext = {};
     uint64_t drmFormatModifier = {};
     uint32_t drmFormatModifierPlaneCount = {};
     const VULKAN_HPP_NAMESPACE::SubresourceLayout* pPlaneLayouts = {};
+
   };
   static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageDrmFormatModifierExplicitCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT>
+  {
+    using Type = ImageDrmFormatModifierExplicitCreateInfoEXT;
+  };
+
   struct ImageDrmFormatModifierListCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierListCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = {},
                                                                   const uint64_t* pDrmFormatModifiers_ = {} ) VULKAN_HPP_NOEXCEPT
       : drmFormatModifierCount( drmFormatModifierCount_ )
@@ -40583,6 +43532,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageDrmFormatModifierListCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>( this );
@@ -40593,6 +43543,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageDrmFormatModifierListCreateInfoEXT const& ) const = default;
 #else
@@ -40610,17 +43561,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT;
     const void* pNext = {};
     uint32_t drmFormatModifierCount = {};
     const uint64_t* pDrmFormatModifiers = {};
+
   };
   static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageDrmFormatModifierListCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageDrmFormatModifierListCreateInfoEXT>
+  {
+    using Type = ImageDrmFormatModifierListCreateInfoEXT;
+  };
+
   struct ImageDrmFormatModifierPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = {} ) VULKAN_HPP_NOEXCEPT
       : drmFormatModifier( drmFormatModifier_ )
     {}
@@ -40642,6 +43604,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageDrmFormatModifierPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT*>( this );
@@ -40652,6 +43615,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageDrmFormatModifierPropertiesEXT const& ) const = default;
 #else
@@ -40668,16 +43632,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT;
     void* pNext = {};
     uint64_t drmFormatModifier = {};
+
   };
   static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageDrmFormatModifierPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageDrmFormatModifierPropertiesEXT>
+  {
+    using Type = ImageDrmFormatModifierPropertiesEXT;
+  };
+
   struct ImageFormatListCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatListCreateInfo;
+
     VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfo( uint32_t viewFormatCount_ = {},
                                                     const VULKAN_HPP_NAMESPACE::Format* pViewFormats_ = {} ) VULKAN_HPP_NOEXCEPT
       : viewFormatCount( viewFormatCount_ )
@@ -40719,6 +43694,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageFormatListCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageFormatListCreateInfo*>( this );
@@ -40729,6 +43705,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageFormatListCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageFormatListCreateInfo const& ) const = default;
 #else
@@ -40746,17 +43723,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageFormatListCreateInfo;
     const void* pNext = {};
     uint32_t viewFormatCount = {};
     const VULKAN_HPP_NAMESPACE::Format* pViewFormats = {};
+
   };
   static_assert( sizeof( ImageFormatListCreateInfo ) == sizeof( VkImageFormatListCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageFormatListCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageFormatListCreateInfo>
+  {
+    using Type = ImageFormatListCreateInfo;
+  };
+
   struct ImageFormatProperties2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatProperties2;
+
     VULKAN_HPP_CONSTEXPR ImageFormatProperties2( VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties_ = {} ) VULKAN_HPP_NOEXCEPT
       : imageFormatProperties( imageFormatProperties_ )
     {}
@@ -40778,6 +43766,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageFormatProperties2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageFormatProperties2*>( this );
@@ -40788,6 +43777,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageFormatProperties2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageFormatProperties2 const& ) const = default;
 #else
@@ -40804,16 +43794,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageFormatProperties2;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties = {};
+
   };
   static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageFormatProperties2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageFormatProperties2>
+  {
+    using Type = ImageFormatProperties2;
+  };
+
   struct ImageSubresourceRange
   {
+
     VULKAN_HPP_CONSTEXPR ImageSubresourceRange( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {},
                                                 uint32_t baseMipLevel_ = {},
                                                 uint32_t levelCount_ = {},
@@ -40867,6 +43867,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageSubresourceRange const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageSubresourceRange*>( this );
@@ -40877,6 +43878,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageSubresourceRange*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageSubresourceRange const& ) const = default;
 #else
@@ -40895,18 +43897,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {};
     uint32_t baseMipLevel = {};
     uint32_t levelCount = {};
     uint32_t baseArrayLayer = {};
     uint32_t layerCount = {};
+
   };
   static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageSubresourceRange>::value, "struct wrapper is not a standard layout!" );
 
   struct ImageMemoryBarrier
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryBarrier;
+
     VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ = {},
                                              VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ = {},
                                              VULKAN_HPP_NAMESPACE::ImageLayout oldLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined,
@@ -40990,12 +43997,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageMemoryBarrier & setSubresourceRange( VULKAN_HPP_NAMESPACE::ImageSubresourceRange subresourceRange_ ) VULKAN_HPP_NOEXCEPT
+    ImageMemoryBarrier & setSubresourceRange( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & subresourceRange_ ) VULKAN_HPP_NOEXCEPT
     {
       subresourceRange = subresourceRange_;
       return *this;
     }
 
+
     operator VkImageMemoryBarrier const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageMemoryBarrier*>( this );
@@ -41006,6 +44014,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageMemoryBarrier*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageMemoryBarrier const& ) const = default;
 #else
@@ -41029,6 +44038,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageMemoryBarrier;
     const void* pNext = {};
@@ -41040,12 +44051,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t dstQueueFamilyIndex = {};
     VULKAN_HPP_NAMESPACE::Image image = {};
     VULKAN_HPP_NAMESPACE::ImageSubresourceRange subresourceRange = {};
+
   };
   static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageMemoryBarrier>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageMemoryBarrier>
+  {
+    using Type = ImageMemoryBarrier;
+  };
+
   struct ImageMemoryRequirementsInfo2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryRequirementsInfo2;
+
     VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( VULKAN_HPP_NAMESPACE::Image image_ = {} ) VULKAN_HPP_NOEXCEPT
       : image( image_ )
     {}
@@ -41079,6 +44099,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageMemoryRequirementsInfo2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( this );
@@ -41089,6 +44110,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageMemoryRequirementsInfo2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageMemoryRequirementsInfo2 const& ) const = default;
 #else
@@ -41105,17 +44127,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageMemoryRequirementsInfo2;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Image image = {};
+
   };
   static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageMemoryRequirementsInfo2>
+  {
+    using Type = ImageMemoryRequirementsInfo2;
+  };
+
 #ifdef VK_USE_PLATFORM_FUCHSIA
   struct ImagePipeSurfaceCreateInfoFUCHSIA
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA;
+
     VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = {},
                                                             zx_handle_t imagePipeHandle_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -41157,6 +44190,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImagePipeSurfaceCreateInfoFUCHSIA const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( this );
@@ -41167,6 +44201,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImagePipeSurfaceCreateInfoFUCHSIA const& ) const = default;
 #else
@@ -41184,18 +44219,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA flags = {};
     zx_handle_t imagePipeHandle = {};
+
   };
   static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImagePipeSurfaceCreateInfoFUCHSIA>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eImagepipeSurfaceCreateInfoFUCHSIA>
+  {
+    using Type = ImagePipeSurfaceCreateInfoFUCHSIA;
+  };
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
   struct ImagePlaneMemoryRequirementsInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImagePlaneMemoryRequirementsInfo;
+
     VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( VULKAN_HPP_NAMESPACE::ImageAspectFlagBits planeAspect_ = VULKAN_HPP_NAMESPACE::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT
       : planeAspect( planeAspect_ )
     {}
@@ -41229,6 +44275,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImagePlaneMemoryRequirementsInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>( this );
@@ -41239,6 +44286,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImagePlaneMemoryRequirementsInfo const& ) const = default;
 #else
@@ -41255,16 +44303,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ImageAspectFlagBits planeAspect = VULKAN_HPP_NAMESPACE::ImageAspectFlagBits::eColor;
+
   };
   static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImagePlaneMemoryRequirementsInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImagePlaneMemoryRequirementsInfo>
+  {
+    using Type = ImagePlaneMemoryRequirementsInfo;
+  };
+
   struct ImageResolve
   {
+
     VULKAN_HPP_CONSTEXPR ImageResolve( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ = {},
                                        VULKAN_HPP_NAMESPACE::Offset3D srcOffset_ = {},
                                        VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ = {},
@@ -41288,36 +44346,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageResolve & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ ) VULKAN_HPP_NOEXCEPT
+    ImageResolve & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
       srcSubresource = srcSubresource_;
       return *this;
     }
 
-    ImageResolve & setSrcOffset( VULKAN_HPP_NAMESPACE::Offset3D srcOffset_ ) VULKAN_HPP_NOEXCEPT
+    ImageResolve & setSrcOffset( VULKAN_HPP_NAMESPACE::Offset3D const & srcOffset_ ) VULKAN_HPP_NOEXCEPT
     {
       srcOffset = srcOffset_;
       return *this;
     }
 
-    ImageResolve & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ ) VULKAN_HPP_NOEXCEPT
+    ImageResolve & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & dstSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
       dstSubresource = dstSubresource_;
       return *this;
     }
 
-    ImageResolve & setDstOffset( VULKAN_HPP_NAMESPACE::Offset3D dstOffset_ ) VULKAN_HPP_NOEXCEPT
+    ImageResolve & setDstOffset( VULKAN_HPP_NAMESPACE::Offset3D const & dstOffset_ ) VULKAN_HPP_NOEXCEPT
     {
       dstOffset = dstOffset_;
       return *this;
     }
 
-    ImageResolve & setExtent( VULKAN_HPP_NAMESPACE::Extent3D extent_ ) VULKAN_HPP_NOEXCEPT
+    ImageResolve & setExtent( VULKAN_HPP_NAMESPACE::Extent3D const & extent_ ) VULKAN_HPP_NOEXCEPT
     {
       extent = extent_;
       return *this;
     }
 
+
     operator VkImageResolve const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageResolve*>( this );
@@ -41328,6 +44387,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageResolve*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageResolve const& ) const = default;
 #else
@@ -41346,18 +44406,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource = {};
     VULKAN_HPP_NAMESPACE::Offset3D srcOffset = {};
     VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource = {};
     VULKAN_HPP_NAMESPACE::Offset3D dstOffset = {};
     VULKAN_HPP_NAMESPACE::Extent3D extent = {};
+
   };
   static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageResolve>::value, "struct wrapper is not a standard layout!" );
 
   struct ImageSparseMemoryRequirementsInfo2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageSparseMemoryRequirementsInfo2;
+
     VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( VULKAN_HPP_NAMESPACE::Image image_ = {} ) VULKAN_HPP_NOEXCEPT
       : image( image_ )
     {}
@@ -41391,6 +44456,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageSparseMemoryRequirementsInfo2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( this );
@@ -41401,6 +44467,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageSparseMemoryRequirementsInfo2 const& ) const = default;
 #else
@@ -41417,16 +44484,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Image image = {};
+
   };
   static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageSparseMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageSparseMemoryRequirementsInfo2>
+  {
+    using Type = ImageSparseMemoryRequirementsInfo2;
+  };
+
   struct ImageStencilUsageCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageStencilUsageCreateInfo;
+
     VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfo( VULKAN_HPP_NAMESPACE::ImageUsageFlags stencilUsage_ = {} ) VULKAN_HPP_NOEXCEPT
       : stencilUsage( stencilUsage_ )
     {}
@@ -41460,6 +44538,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageStencilUsageCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageStencilUsageCreateInfo*>( this );
@@ -41470,6 +44549,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageStencilUsageCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageStencilUsageCreateInfo const& ) const = default;
 #else
@@ -41486,16 +44566,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageStencilUsageCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ImageUsageFlags stencilUsage = {};
+
   };
   static_assert( sizeof( ImageStencilUsageCreateInfo ) == sizeof( VkImageStencilUsageCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageStencilUsageCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageStencilUsageCreateInfo>
+  {
+    using Type = ImageStencilUsageCreateInfo;
+  };
+
   struct ImageSwapchainCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageSwapchainCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain_ = {} ) VULKAN_HPP_NOEXCEPT
       : swapchain( swapchain_ )
     {}
@@ -41529,6 +44620,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageSwapchainCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>( this );
@@ -41539,6 +44631,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageSwapchainCreateInfoKHR const& ) const = default;
 #else
@@ -41555,16 +44648,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageSwapchainCreateInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain = {};
+
   };
   static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageSwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageSwapchainCreateInfoKHR>
+  {
+    using Type = ImageSwapchainCreateInfoKHR;
+  };
+
   struct ImageViewASTCDecodeModeEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewAstcDecodeModeEXT;
+
     VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( VULKAN_HPP_NAMESPACE::Format decodeMode_ = VULKAN_HPP_NAMESPACE::Format::eUndefined ) VULKAN_HPP_NOEXCEPT
       : decodeMode( decodeMode_ )
     {}
@@ -41598,6 +44702,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageViewASTCDecodeModeEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>( this );
@@ -41608,6 +44713,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageViewASTCDecodeModeEXT const& ) const = default;
 #else
@@ -41624,16 +44730,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewAstcDecodeModeEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Format decodeMode = VULKAN_HPP_NAMESPACE::Format::eUndefined;
+
   };
   static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageViewASTCDecodeModeEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageViewAstcDecodeModeEXT>
+  {
+    using Type = ImageViewASTCDecodeModeEXT;
+  };
+
   struct ImageViewAddressPropertiesNVX
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewAddressPropertiesNVX;
+
     VULKAN_HPP_CONSTEXPR ImageViewAddressPropertiesNVX( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ = {},
                                                         VULKAN_HPP_NAMESPACE::DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT
       : deviceAddress( deviceAddress_ )
@@ -41657,6 +44774,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageViewAddressPropertiesNVX const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageViewAddressPropertiesNVX*>( this );
@@ -41667,6 +44785,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageViewAddressPropertiesNVX*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageViewAddressPropertiesNVX const& ) const = default;
 #else
@@ -41684,17 +44803,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewAddressPropertiesNVX;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress = {};
     VULKAN_HPP_NAMESPACE::DeviceSize size = {};
+
   };
   static_assert( sizeof( ImageViewAddressPropertiesNVX ) == sizeof( VkImageViewAddressPropertiesNVX ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageViewAddressPropertiesNVX>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageViewAddressPropertiesNVX>
+  {
+    using Type = ImageViewAddressPropertiesNVX;
+  };
+
   struct ImageViewCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewCreateInfo;
+
     VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( VULKAN_HPP_NAMESPACE::ImageViewCreateFlags flags_ = {},
                                               VULKAN_HPP_NAMESPACE::Image image_ = {},
                                               VULKAN_HPP_NAMESPACE::ImageViewType viewType_ = VULKAN_HPP_NAMESPACE::ImageViewType::e1D,
@@ -41756,18 +44886,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageViewCreateInfo & setComponents( VULKAN_HPP_NAMESPACE::ComponentMapping components_ ) VULKAN_HPP_NOEXCEPT
+    ImageViewCreateInfo & setComponents( VULKAN_HPP_NAMESPACE::ComponentMapping const & components_ ) VULKAN_HPP_NOEXCEPT
     {
       components = components_;
       return *this;
     }
 
-    ImageViewCreateInfo & setSubresourceRange( VULKAN_HPP_NAMESPACE::ImageSubresourceRange subresourceRange_ ) VULKAN_HPP_NOEXCEPT
+    ImageViewCreateInfo & setSubresourceRange( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & subresourceRange_ ) VULKAN_HPP_NOEXCEPT
     {
       subresourceRange = subresourceRange_;
       return *this;
     }
 
+
     operator VkImageViewCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageViewCreateInfo*>( this );
@@ -41778,6 +44909,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageViewCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageViewCreateInfo const& ) const = default;
 #else
@@ -41799,6 +44931,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewCreateInfo;
     const void* pNext = {};
@@ -41808,12 +44942,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Format format = VULKAN_HPP_NAMESPACE::Format::eUndefined;
     VULKAN_HPP_NAMESPACE::ComponentMapping components = {};
     VULKAN_HPP_NAMESPACE::ImageSubresourceRange subresourceRange = {};
+
   };
   static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageViewCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageViewCreateInfo>
+  {
+    using Type = ImageViewCreateInfo;
+  };
+
   struct ImageViewHandleInfoNVX
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewHandleInfoNVX;
+
     VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( VULKAN_HPP_NAMESPACE::ImageView imageView_ = {},
                                                  VULKAN_HPP_NAMESPACE::DescriptorType descriptorType_ = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler,
                                                  VULKAN_HPP_NAMESPACE::Sampler sampler_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -41863,6 +45006,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageViewHandleInfoNVX const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageViewHandleInfoNVX*>( this );
@@ -41873,6 +45017,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageViewHandleInfoNVX*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageViewHandleInfoNVX const& ) const = default;
 #else
@@ -41891,18 +45036,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewHandleInfoNVX;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ImageView imageView = {};
     VULKAN_HPP_NAMESPACE::DescriptorType descriptorType = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler;
     VULKAN_HPP_NAMESPACE::Sampler sampler = {};
+
   };
   static_assert( sizeof( ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageViewHandleInfoNVX>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageViewHandleInfoNVX>
+  {
+    using Type = ImageViewHandleInfoNVX;
+  };
+
   struct ImageViewUsageCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewUsageCreateInfo;
+
     VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( VULKAN_HPP_NAMESPACE::ImageUsageFlags usage_ = {} ) VULKAN_HPP_NOEXCEPT
       : usage( usage_ )
     {}
@@ -41936,6 +45092,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImageViewUsageCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImageViewUsageCreateInfo*>( this );
@@ -41946,6 +45103,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageViewUsageCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImageViewUsageCreateInfo const& ) const = default;
 #else
@@ -41962,17 +45120,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewUsageCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ImageUsageFlags usage = {};
+
   };
   static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageViewUsageCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImageViewUsageCreateInfo>
+  {
+    using Type = ImageViewUsageCreateInfo;
+  };
+
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   struct ImportAndroidHardwareBufferInfoANDROID
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportAndroidHardwareBufferInfoANDROID;
+
     VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = {} ) VULKAN_HPP_NOEXCEPT
       : buffer( buffer_ )
     {}
@@ -42006,6 +45175,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImportAndroidHardwareBufferInfoANDROID const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>( this );
@@ -42016,6 +45186,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImportAndroidHardwareBufferInfoANDROID const& ) const = default;
 #else
@@ -42032,17 +45203,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID;
     const void* pNext = {};
     struct AHardwareBuffer* buffer = {};
+
   };
   static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportAndroidHardwareBufferInfoANDROID>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eImportAndroidHardwareBufferInfoANDROID>
+  {
+    using Type = ImportAndroidHardwareBufferInfoANDROID;
+  };
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct ImportFenceFdInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportFenceFdInfoKHR;
+
     VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {},
                                                VULKAN_HPP_NAMESPACE::FenceImportFlags flags_ = {},
                                                VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
@@ -42100,6 +45282,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImportFenceFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportFenceFdInfoKHR*>( this );
@@ -42110,6 +45293,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportFenceFdInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImportFenceFdInfoKHR const& ) const = default;
 #else
@@ -42129,6 +45313,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportFenceFdInfoKHR;
     const void* pNext = {};
@@ -42136,13 +45322,22 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::FenceImportFlags flags = {};
     VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd;
     int fd = {};
+
   };
   static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportFenceFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImportFenceFdInfoKHR>
+  {
+    using Type = ImportFenceFdInfoKHR;
+  };
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct ImportFenceWin32HandleInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportFenceWin32HandleInfoKHR;
+
     VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {},
                                                         VULKAN_HPP_NAMESPACE::FenceImportFlags flags_ = {},
                                                         VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
@@ -42208,6 +45403,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImportFenceWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( this );
@@ -42218,6 +45414,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImportFenceWin32HandleInfoKHR const& ) const = default;
 #else
@@ -42238,6 +45435,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
     const void* pNext = {};
@@ -42246,13 +45445,22 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd;
     HANDLE handle = {};
     LPCWSTR name = {};
+
   };
   static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportFenceWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eImportFenceWin32HandleInfoKHR>
+  {
+    using Type = ImportFenceWin32HandleInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ImportMemoryFdInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryFdInfoKHR;
+
     VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
                                                 int fd_ = {} ) VULKAN_HPP_NOEXCEPT
       : handleType( handleType_ )
@@ -42294,6 +45502,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImportMemoryFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportMemoryFdInfoKHR*>( this );
@@ -42304,6 +45513,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportMemoryFdInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImportMemoryFdInfoKHR const& ) const = default;
 #else
@@ -42321,17 +45531,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportMemoryFdInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd;
     int fd = {};
+
   };
   static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportMemoryFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImportMemoryFdInfoKHR>
+  {
+    using Type = ImportMemoryFdInfoKHR;
+  };
+
   struct ImportMemoryHostPointerInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryHostPointerInfoEXT;
+
     VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
                                                          void* pHostPointer_ = {} ) VULKAN_HPP_NOEXCEPT
       : handleType( handleType_ )
@@ -42373,6 +45594,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImportMemoryHostPointerInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>( this );
@@ -42383,6 +45605,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImportMemoryHostPointerInfoEXT const& ) const = default;
 #else
@@ -42400,18 +45623,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd;
     void* pHostPointer = {};
+
   };
   static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportMemoryHostPointerInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImportMemoryHostPointerInfoEXT>
+  {
+    using Type = ImportMemoryHostPointerInfoEXT;
+  };
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct ImportMemoryWin32HandleInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryWin32HandleInfoKHR;
+
     VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
                                                          HANDLE handle_ = {},
                                                          LPCWSTR name_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -42461,6 +45695,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImportMemoryWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>( this );
@@ -42471,6 +45706,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImportMemoryWin32HandleInfoKHR const& ) const = default;
 #else
@@ -42489,20 +45725,31 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd;
     HANDLE handle = {};
     LPCWSTR name = {};
+
   };
   static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportMemoryWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eImportMemoryWin32HandleInfoKHR>
+  {
+    using Type = ImportMemoryWin32HandleInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct ImportMemoryWin32HandleInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryWin32HandleInfoNV;
+
     VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType_ = {},
                                                         HANDLE handle_ = {} ) VULKAN_HPP_NOEXCEPT
       : handleType( handleType_ )
@@ -42544,6 +45791,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImportMemoryWin32HandleInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>( this );
@@ -42554,6 +45802,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImportMemoryWin32HandleInfoNV const& ) const = default;
 #else
@@ -42571,18 +45820,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType = {};
     HANDLE handle = {};
+
   };
   static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportMemoryWin32HandleInfoNV>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eImportMemoryWin32HandleInfoNV>
+  {
+    using Type = ImportMemoryWin32HandleInfoNV;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ImportSemaphoreFdInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportSemaphoreFdInfoKHR;
+
     VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {},
                                                    VULKAN_HPP_NAMESPACE::SemaphoreImportFlags flags_ = {},
                                                    VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
@@ -42640,6 +45900,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImportSemaphoreFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( this );
@@ -42650,6 +45911,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImportSemaphoreFdInfoKHR const& ) const = default;
 #else
@@ -42669,6 +45931,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
     const void* pNext = {};
@@ -42676,13 +45940,22 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::SemaphoreImportFlags flags = {};
     VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd;
     int fd = {};
+
   };
   static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportSemaphoreFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eImportSemaphoreFdInfoKHR>
+  {
+    using Type = ImportSemaphoreFdInfoKHR;
+  };
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct ImportSemaphoreWin32HandleInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
+
     VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {},
                                                             VULKAN_HPP_NAMESPACE::SemaphoreImportFlags flags_ = {},
                                                             VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
@@ -42748,6 +46021,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkImportSemaphoreWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( this );
@@ -42758,6 +46032,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ImportSemaphoreWin32HandleInfoKHR const& ) const = default;
 #else
@@ -42778,6 +46053,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
     const void* pNext = {};
@@ -42786,13 +46063,22 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd;
     HANDLE handle = {};
     LPCWSTR name = {};
+
   };
   static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportSemaphoreWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eImportSemaphoreWin32HandleInfoKHR>
+  {
+    using Type = ImportSemaphoreWin32HandleInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct IndirectCommandsLayoutTokenNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutTokenNV;
+
     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNV( VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV tokenType_ = VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV::eShaderGroup,
                                                         uint32_t stream_ = {},
                                                         uint32_t offset_ = {},
@@ -42922,6 +46208,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkIndirectCommandsLayoutTokenNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNV*>( this );
@@ -42932,6 +46219,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkIndirectCommandsLayoutTokenNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( IndirectCommandsLayoutTokenNV const& ) const = default;
 #else
@@ -42960,6 +46248,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eIndirectCommandsLayoutTokenNV;
     const void* pNext = {};
@@ -42976,12 +46266,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t indexTypeCount = {};
     const VULKAN_HPP_NAMESPACE::IndexType* pIndexTypes = {};
     const uint32_t* pIndexTypeValues = {};
+
   };
   static_assert( sizeof( IndirectCommandsLayoutTokenNV ) == sizeof( VkIndirectCommandsLayoutTokenNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<IndirectCommandsLayoutTokenNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eIndirectCommandsLayoutTokenNV>
+  {
+    using Type = IndirectCommandsLayoutTokenNV;
+  };
+
   struct IndirectCommandsLayoutCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV flags_ = {},
                                                              VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics,
                                                              uint32_t tokenCount_ = {},
@@ -43055,6 +46354,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkIndirectCommandsLayoutCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV*>( this );
@@ -43065,6 +46365,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( IndirectCommandsLayoutCreateInfoNV const& ) const = default;
 #else
@@ -43086,6 +46387,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNV;
     const void* pNext = {};
@@ -43095,12 +46398,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV* pTokens = {};
     uint32_t streamCount = {};
     const uint32_t* pStreamStrides = {};
+
   };
   static_assert( sizeof( IndirectCommandsLayoutCreateInfoNV ) == sizeof( VkIndirectCommandsLayoutCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<IndirectCommandsLayoutCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eIndirectCommandsLayoutCreateInfoNV>
+  {
+    using Type = IndirectCommandsLayoutCreateInfoNV;
+  };
+
   struct InitializePerformanceApiInfoINTEL
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eInitializePerformanceApiInfoINTEL;
+
     VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void* pUserData_ = {} ) VULKAN_HPP_NOEXCEPT
       : pUserData( pUserData_ )
     {}
@@ -43134,6 +46446,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkInitializePerformanceApiInfoINTEL const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkInitializePerformanceApiInfoINTEL*>( this );
@@ -43144,6 +46457,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkInitializePerformanceApiInfoINTEL*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( InitializePerformanceApiInfoINTEL const& ) const = default;
 #else
@@ -43160,16 +46474,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL;
     const void* pNext = {};
     void* pUserData = {};
+
   };
   static_assert( sizeof( InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<InitializePerformanceApiInfoINTEL>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eInitializePerformanceApiInfoINTEL>
+  {
+    using Type = InitializePerformanceApiInfoINTEL;
+  };
+
   struct InputAttachmentAspectReference
   {
+
     VULKAN_HPP_CONSTEXPR InputAttachmentAspectReference( uint32_t subpass_ = {},
                                                          uint32_t inputAttachmentIndex_ = {},
                                                          VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -43207,6 +46531,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkInputAttachmentAspectReference const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkInputAttachmentAspectReference*>( this );
@@ -43217,6 +46542,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkInputAttachmentAspectReference*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( InputAttachmentAspectReference const& ) const = default;
 #else
@@ -43233,16 +46559,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t subpass = {};
     uint32_t inputAttachmentIndex = {};
     VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {};
+
   };
   static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<InputAttachmentAspectReference>::value, "struct wrapper is not a standard layout!" );
 
   struct InstanceCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eInstanceCreateInfo;
+
     VULKAN_HPP_CONSTEXPR InstanceCreateInfo( VULKAN_HPP_NAMESPACE::InstanceCreateFlags flags_ = {},
                                              const VULKAN_HPP_NAMESPACE::ApplicationInfo* pApplicationInfo_ = {},
                                              uint32_t enabledLayerCount_ = {},
@@ -43316,6 +46647,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkInstanceCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkInstanceCreateInfo*>( this );
@@ -43326,6 +46658,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkInstanceCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( InstanceCreateInfo const& ) const = default;
 #else
@@ -43347,6 +46680,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eInstanceCreateInfo;
     const void* pNext = {};
@@ -43356,12 +46691,20 @@ namespace VULKAN_HPP_NAMESPACE
     const char* const* ppEnabledLayerNames = {};
     uint32_t enabledExtensionCount = {};
     const char* const* ppEnabledExtensionNames = {};
+
   };
   static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<InstanceCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eInstanceCreateInfo>
+  {
+    using Type = InstanceCreateInfo;
+  };
+
   struct LayerProperties
   {
+
     VULKAN_HPP_CONSTEXPR_14 LayerProperties( std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& layerName_ = {},
                                              uint32_t specVersion_ = {},
                                              uint32_t implementationVersion_ = {},
@@ -43383,6 +46726,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkLayerProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkLayerProperties*>( this );
@@ -43393,6 +46737,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkLayerProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( LayerProperties const& ) const = default;
 #else
@@ -43410,11 +46755,14 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> layerName = {};
     uint32_t specVersion = {};
     uint32_t implementationVersion = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {};
+
   };
   static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<LayerProperties>::value, "struct wrapper is not a standard layout!" );
@@ -43422,6 +46770,8 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_USE_PLATFORM_MACOS_MVK
   struct MacOSSurfaceCreateInfoMVK
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMacosSurfaceCreateInfoMVK;
+
     VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK flags_ = {},
                                                     const void* pView_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -43463,6 +46813,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMacOSSurfaceCreateInfoMVK const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( this );
@@ -43473,6 +46824,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MacOSSurfaceCreateInfoMVK const& ) const = default;
 #else
@@ -43490,18 +46842,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK flags = {};
     const void* pView = {};
+
   };
   static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MacOSSurfaceCreateInfoMVK>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eMacosSurfaceCreateInfoMVK>
+  {
+    using Type = MacOSSurfaceCreateInfoMVK;
+  };
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
 
   struct MappedMemoryRange
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMappedMemoryRange;
+
     VULKAN_HPP_CONSTEXPR MappedMemoryRange( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {},
                                             VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {},
                                             VULKAN_HPP_NAMESPACE::DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -43551,6 +46914,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMappedMemoryRange const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMappedMemoryRange*>( this );
@@ -43561,6 +46925,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMappedMemoryRange*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MappedMemoryRange const& ) const = default;
 #else
@@ -43579,18 +46944,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMappedMemoryRange;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
     VULKAN_HPP_NAMESPACE::DeviceSize offset = {};
     VULKAN_HPP_NAMESPACE::DeviceSize size = {};
+
   };
   static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MappedMemoryRange>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMappedMemoryRange>
+  {
+    using Type = MappedMemoryRange;
+  };
+
   struct MemoryAllocateFlagsInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryAllocateFlagsInfo;
+
     VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( VULKAN_HPP_NAMESPACE::MemoryAllocateFlags flags_ = {},
                                                   uint32_t deviceMask_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -43632,6 +47008,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryAllocateFlagsInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryAllocateFlagsInfo*>( this );
@@ -43642,6 +47019,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryAllocateFlagsInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryAllocateFlagsInfo const& ) const = default;
 #else
@@ -43659,17 +47037,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryAllocateFlagsInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::MemoryAllocateFlags flags = {};
     uint32_t deviceMask = {};
+
   };
   static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryAllocateFlagsInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryAllocateFlagsInfo>
+  {
+    using Type = MemoryAllocateFlagsInfo;
+  };
+
   struct MemoryAllocateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryAllocateInfo;
+
     VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( VULKAN_HPP_NAMESPACE::DeviceSize allocationSize_ = {},
                                              uint32_t memoryTypeIndex_ = {} ) VULKAN_HPP_NOEXCEPT
       : allocationSize( allocationSize_ )
@@ -43711,6 +47100,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryAllocateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryAllocateInfo*>( this );
@@ -43721,6 +47111,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryAllocateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryAllocateInfo const& ) const = default;
 #else
@@ -43738,17 +47129,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryAllocateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceSize allocationSize = {};
     uint32_t memoryTypeIndex = {};
+
   };
   static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryAllocateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryAllocateInfo>
+  {
+    using Type = MemoryAllocateInfo;
+  };
+
   struct MemoryBarrier
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryBarrier;
+
     VULKAN_HPP_CONSTEXPR MemoryBarrier( VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ = {},
                                         VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ = {} ) VULKAN_HPP_NOEXCEPT
       : srcAccessMask( srcAccessMask_ )
@@ -43790,6 +47192,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryBarrier const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryBarrier*>( this );
@@ -43800,6 +47203,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryBarrier*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryBarrier const& ) const = default;
 #else
@@ -43817,17 +47221,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryBarrier;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask = {};
     VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask = {};
+
   };
   static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryBarrier>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryBarrier>
+  {
+    using Type = MemoryBarrier;
+  };
+
   struct MemoryDedicatedAllocateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedAllocateInfo;
+
     VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( VULKAN_HPP_NAMESPACE::Image image_ = {},
                                                       VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT
       : image( image_ )
@@ -43869,6 +47284,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryDedicatedAllocateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>( this );
@@ -43879,6 +47295,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryDedicatedAllocateInfo const& ) const = default;
 #else
@@ -43896,17 +47313,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryDedicatedAllocateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Image image = {};
     VULKAN_HPP_NAMESPACE::Buffer buffer = {};
+
   };
   static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryDedicatedAllocateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryDedicatedAllocateInfo>
+  {
+    using Type = MemoryDedicatedAllocateInfo;
+  };
+
   struct MemoryDedicatedRequirements
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedRequirements;
+
     VULKAN_HPP_CONSTEXPR MemoryDedicatedRequirements( VULKAN_HPP_NAMESPACE::Bool32 prefersDedicatedAllocation_ = {},
                                                       VULKAN_HPP_NAMESPACE::Bool32 requiresDedicatedAllocation_ = {} ) VULKAN_HPP_NOEXCEPT
       : prefersDedicatedAllocation( prefersDedicatedAllocation_ )
@@ -43930,6 +47358,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryDedicatedRequirements const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryDedicatedRequirements*>( this );
@@ -43940,6 +47369,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryDedicatedRequirements*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryDedicatedRequirements const& ) const = default;
 #else
@@ -43957,17 +47387,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryDedicatedRequirements;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 prefersDedicatedAllocation = {};
     VULKAN_HPP_NAMESPACE::Bool32 requiresDedicatedAllocation = {};
+
   };
   static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryDedicatedRequirements>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryDedicatedRequirements>
+  {
+    using Type = MemoryDedicatedRequirements;
+  };
+
   struct MemoryFdPropertiesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryFdPropertiesKHR;
+
     VULKAN_HPP_CONSTEXPR MemoryFdPropertiesKHR( uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT
       : memoryTypeBits( memoryTypeBits_ )
     {}
@@ -43989,6 +47430,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryFdPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryFdPropertiesKHR*>( this );
@@ -43999,6 +47441,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryFdPropertiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryFdPropertiesKHR const& ) const = default;
 #else
@@ -44015,17 +47458,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryFdPropertiesKHR;
     void* pNext = {};
     uint32_t memoryTypeBits = {};
+
   };
   static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryFdPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryFdPropertiesKHR>
+  {
+    using Type = MemoryFdPropertiesKHR;
+  };
+
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   struct MemoryGetAndroidHardwareBufferInfoANDROID
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID;
+
     VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {} ) VULKAN_HPP_NOEXCEPT
       : memory( memory_ )
     {}
@@ -44059,6 +47513,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryGetAndroidHardwareBufferInfoANDROID const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>( this );
@@ -44069,6 +47524,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryGetAndroidHardwareBufferInfoANDROID const& ) const = default;
 #else
@@ -44085,17 +47541,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
+
   };
   static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryGetAndroidHardwareBufferInfoANDROID>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID>
+  {
+    using Type = MemoryGetAndroidHardwareBufferInfoANDROID;
+  };
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   struct MemoryGetFdInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetFdInfoKHR;
+
     VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {},
                                              VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
       : memory( memory_ )
@@ -44137,6 +47604,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryGetFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryGetFdInfoKHR*>( this );
@@ -44147,6 +47615,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryGetFdInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryGetFdInfoKHR const& ) const = default;
 #else
@@ -44164,18 +47633,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryGetFdInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd;
+
   };
   static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryGetFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryGetFdInfoKHR>
+  {
+    using Type = MemoryGetFdInfoKHR;
+  };
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct MemoryGetWin32HandleInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetWin32HandleInfoKHR;
+
     VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {},
                                                       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
       : memory( memory_ )
@@ -44217,6 +47697,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryGetWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( this );
@@ -44227,6 +47708,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryGetWin32HandleInfoKHR const& ) const = default;
 #else
@@ -44244,18 +47726,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd;
+
   };
   static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryGetWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryGetWin32HandleInfoKHR>
+  {
+    using Type = MemoryGetWin32HandleInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct MemoryHeap
   {
+
     VULKAN_HPP_CONSTEXPR MemoryHeap( VULKAN_HPP_NAMESPACE::DeviceSize size_ = {},
                                      VULKAN_HPP_NAMESPACE::MemoryHeapFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT
       : size( size_ )
@@ -44273,6 +47765,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryHeap const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryHeap*>( this );
@@ -44283,6 +47776,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryHeap*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryHeap const& ) const = default;
 #else
@@ -44298,15 +47792,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DeviceSize size = {};
     VULKAN_HPP_NAMESPACE::MemoryHeapFlags flags = {};
+
   };
   static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryHeap>::value, "struct wrapper is not a standard layout!" );
 
   struct MemoryHostPointerPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryHostPointerPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT
       : memoryTypeBits( memoryTypeBits_ )
     {}
@@ -44328,6 +47827,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryHostPointerPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>( this );
@@ -44338,6 +47838,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryHostPointerPropertiesEXT const& ) const = default;
 #else
@@ -44354,16 +47855,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT;
     void* pNext = {};
     uint32_t memoryTypeBits = {};
+
   };
   static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryHostPointerPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryHostPointerPropertiesEXT>
+  {
+    using Type = MemoryHostPointerPropertiesEXT;
+  };
+
   struct MemoryOpaqueCaptureAddressAllocateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryOpaqueCaptureAddressAllocateInfo;
+
     VULKAN_HPP_CONSTEXPR MemoryOpaqueCaptureAddressAllocateInfo( uint64_t opaqueCaptureAddress_ = {} ) VULKAN_HPP_NOEXCEPT
       : opaqueCaptureAddress( opaqueCaptureAddress_ )
     {}
@@ -44397,6 +47909,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryOpaqueCaptureAddressAllocateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>( this );
@@ -44407,6 +47920,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryOpaqueCaptureAddressAllocateInfo const& ) const = default;
 #else
@@ -44423,16 +47937,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryOpaqueCaptureAddressAllocateInfo;
     const void* pNext = {};
     uint64_t opaqueCaptureAddress = {};
+
   };
   static_assert( sizeof( MemoryOpaqueCaptureAddressAllocateInfo ) == sizeof( VkMemoryOpaqueCaptureAddressAllocateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryOpaqueCaptureAddressAllocateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryOpaqueCaptureAddressAllocateInfo>
+  {
+    using Type = MemoryOpaqueCaptureAddressAllocateInfo;
+  };
+
   struct MemoryPriorityAllocateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryPriorityAllocateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = {} ) VULKAN_HPP_NOEXCEPT
       : priority( priority_ )
     {}
@@ -44466,6 +47991,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryPriorityAllocateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>( this );
@@ -44476,6 +48002,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryPriorityAllocateInfoEXT const& ) const = default;
 #else
@@ -44492,16 +48019,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT;
     const void* pNext = {};
     float priority = {};
+
   };
   static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryPriorityAllocateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryPriorityAllocateInfoEXT>
+  {
+    using Type = MemoryPriorityAllocateInfoEXT;
+  };
+
   struct MemoryRequirements
   {
+
     VULKAN_HPP_CONSTEXPR MemoryRequirements( VULKAN_HPP_NAMESPACE::DeviceSize size_ = {},
                                              VULKAN_HPP_NAMESPACE::DeviceSize alignment_ = {},
                                              uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -44521,6 +48058,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryRequirements const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryRequirements*>( this );
@@ -44531,6 +48069,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryRequirements*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryRequirements const& ) const = default;
 #else
@@ -44547,16 +48086,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::DeviceSize size = {};
     VULKAN_HPP_NAMESPACE::DeviceSize alignment = {};
     uint32_t memoryTypeBits = {};
+
   };
   static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryRequirements>::value, "struct wrapper is not a standard layout!" );
 
   struct MemoryRequirements2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryRequirements2;
+
     VULKAN_HPP_CONSTEXPR MemoryRequirements2( VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements_ = {} ) VULKAN_HPP_NOEXCEPT
       : memoryRequirements( memoryRequirements_ )
     {}
@@ -44578,6 +48122,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryRequirements2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryRequirements2*>( this );
@@ -44588,6 +48133,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryRequirements2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryRequirements2 const& ) const = default;
 #else
@@ -44604,16 +48150,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryRequirements2;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements = {};
+
   };
   static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryRequirements2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryRequirements2>
+  {
+    using Type = MemoryRequirements2;
+  };
+
   struct MemoryType
   {
+
     VULKAN_HPP_CONSTEXPR MemoryType( VULKAN_HPP_NAMESPACE::MemoryPropertyFlags propertyFlags_ = {},
                                      uint32_t heapIndex_ = {} ) VULKAN_HPP_NOEXCEPT
       : propertyFlags( propertyFlags_ )
@@ -44631,6 +48187,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryType const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryType*>( this );
@@ -44641,6 +48198,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryType*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryType const& ) const = default;
 #else
@@ -44656,9 +48214,12 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::MemoryPropertyFlags propertyFlags = {};
     uint32_t heapIndex = {};
+
   };
   static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryType>::value, "struct wrapper is not a standard layout!" );
@@ -44666,6 +48227,8 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct MemoryWin32HandlePropertiesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryWin32HandlePropertiesKHR;
+
     VULKAN_HPP_CONSTEXPR MemoryWin32HandlePropertiesKHR( uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT
       : memoryTypeBits( memoryTypeBits_ )
     {}
@@ -44687,6 +48250,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMemoryWin32HandlePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>( this );
@@ -44697,6 +48261,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MemoryWin32HandlePropertiesKHR const& ) const = default;
 #else
@@ -44713,18 +48278,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR;
     void* pNext = {};
     uint32_t memoryTypeBits = {};
+
   };
   static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryWin32HandlePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eMemoryWin32HandlePropertiesKHR>
+  {
+    using Type = MemoryWin32HandlePropertiesKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_METAL_EXT
   struct MetalSurfaceCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMetalSurfaceCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT flags_ = {},
                                                     const CAMetalLayer* pLayer_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -44766,6 +48342,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMetalSurfaceCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>( this );
@@ -44776,6 +48353,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMetalSurfaceCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MetalSurfaceCreateInfoEXT const& ) const = default;
 #else
@@ -44793,18 +48371,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT flags = {};
     const CAMetalLayer* pLayer = {};
+
   };
   static_assert( sizeof( MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MetalSurfaceCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eMetalSurfaceCreateInfoEXT>
+  {
+    using Type = MetalSurfaceCreateInfoEXT;
+  };
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
 
   struct MultisamplePropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultisamplePropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR MultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::Extent2D maxSampleLocationGridSize_ = {} ) VULKAN_HPP_NOEXCEPT
       : maxSampleLocationGridSize( maxSampleLocationGridSize_ )
     {}
@@ -44826,6 +48415,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkMultisamplePropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkMultisamplePropertiesEXT*>( this );
@@ -44836,6 +48426,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMultisamplePropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( MultisamplePropertiesEXT const& ) const = default;
 #else
@@ -44852,16 +48443,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMultisamplePropertiesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Extent2D maxSampleLocationGridSize = {};
+
   };
   static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MultisamplePropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eMultisamplePropertiesEXT>
+  {
+    using Type = MultisamplePropertiesEXT;
+  };
+
   struct PastPresentationTimingGOOGLE
   {
+
     VULKAN_HPP_CONSTEXPR PastPresentationTimingGOOGLE( uint32_t presentID_ = {},
                                                        uint64_t desiredPresentTime_ = {},
                                                        uint64_t actualPresentTime_ = {},
@@ -44885,6 +48486,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPastPresentationTimingGOOGLE const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPastPresentationTimingGOOGLE*>( this );
@@ -44895,6 +48497,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPastPresentationTimingGOOGLE*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PastPresentationTimingGOOGLE const& ) const = default;
 #else
@@ -44913,18 +48516,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t presentID = {};
     uint64_t desiredPresentTime = {};
     uint64_t actualPresentTime = {};
     uint64_t earliestPresentTime = {};
     uint64_t presentMargin = {};
+
   };
   static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PastPresentationTimingGOOGLE>::value, "struct wrapper is not a standard layout!" );
 
   struct PerformanceConfigurationAcquireInfoINTEL
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceConfigurationAcquireInfoINTEL;
+
     VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL type_ = VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated ) VULKAN_HPP_NOEXCEPT
       : type( type_ )
     {}
@@ -44958,6 +48566,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPerformanceConfigurationAcquireInfoINTEL const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL*>( this );
@@ -44968,6 +48577,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PerformanceConfigurationAcquireInfoINTEL const& ) const = default;
 #else
@@ -44984,16 +48594,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated;
+
   };
   static_assert( sizeof( PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PerformanceConfigurationAcquireInfoINTEL>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePerformanceConfigurationAcquireInfoINTEL>
+  {
+    using Type = PerformanceConfigurationAcquireInfoINTEL;
+  };
+
   struct PerformanceCounterDescriptionKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterDescriptionKHR;
+
     VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR flags_ = {},
                                                               std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = {},
                                                               std::array<char,VK_MAX_DESCRIPTION_SIZE> const& category_ = {},
@@ -45021,6 +48642,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPerformanceCounterDescriptionKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceCounterDescriptionKHR*>( this );
@@ -45031,6 +48653,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceCounterDescriptionKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PerformanceCounterDescriptionKHR const& ) const = default;
 #else
@@ -45050,6 +48673,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceCounterDescriptionKHR;
     const void* pNext = {};
@@ -45057,12 +48682,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> name = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> category = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {};
+
   };
   static_assert( sizeof( PerformanceCounterDescriptionKHR ) == sizeof( VkPerformanceCounterDescriptionKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PerformanceCounterDescriptionKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePerformanceCounterDescriptionKHR>
+  {
+    using Type = PerformanceCounterDescriptionKHR;
+  };
+
   struct PerformanceCounterKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterKHR;
+
     VULKAN_HPP_CONSTEXPR_14 PerformanceCounterKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR unit_ = VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR::eGeneric,
                                                    VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR scope_ = VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR::eCommandBuffer,
                                                    VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR storage_ = VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR::eInt32,
@@ -45090,6 +48724,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPerformanceCounterKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceCounterKHR*>( this );
@@ -45100,6 +48735,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceCounterKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PerformanceCounterKHR const& ) const = default;
 #else
@@ -45119,6 +48755,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceCounterKHR;
     const void* pNext = {};
@@ -45126,10 +48764,17 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR scope = VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR::eCommandBuffer;
     VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR storage = VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR::eInt32;
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> uuid = {};
+
   };
   static_assert( sizeof( PerformanceCounterKHR ) == sizeof( VkPerformanceCounterKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PerformanceCounterKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePerformanceCounterKHR>
+  {
+    using Type = PerformanceCounterKHR;
+  };
+
   union PerformanceCounterResultKHR
   {
     PerformanceCounterResultKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR const& rhs ) VULKAN_HPP_NOEXCEPT
@@ -45138,34 +48783,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     PerformanceCounterResultKHR( int32_t int32_ = {} )
-    {
-      int32 = int32_;
-    }
+      : int32( int32_ )
+    {}
 
     PerformanceCounterResultKHR( int64_t int64_ )
-    {
-      int64 = int64_;
-    }
+      : int64( int64_ )
+    {}
 
     PerformanceCounterResultKHR( uint32_t uint32_ )
-    {
-      uint32 = uint32_;
-    }
+      : uint32( uint32_ )
+    {}
 
     PerformanceCounterResultKHR( uint64_t uint64_ )
-    {
-      uint64 = uint64_;
-    }
+      : uint64( uint64_ )
+    {}
 
     PerformanceCounterResultKHR( float float32_ )
-    {
-      float32 = float32_;
-    }
+      : float32( float32_ )
+    {}
 
     PerformanceCounterResultKHR( double float64_ )
-    {
-      float64 = float64_;
-    }
+      : float64( float64_ )
+    {}
 
     PerformanceCounterResultKHR & setInt32( int32_t int32_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -45229,6 +48868,8 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PerformanceMarkerInfoINTEL
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceMarkerInfoINTEL;
+
     VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = {} ) VULKAN_HPP_NOEXCEPT
       : marker( marker_ )
     {}
@@ -45262,6 +48903,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPerformanceMarkerInfoINTEL const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceMarkerInfoINTEL*>( this );
@@ -45272,6 +48914,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceMarkerInfoINTEL*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PerformanceMarkerInfoINTEL const& ) const = default;
 #else
@@ -45288,16 +48931,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceMarkerInfoINTEL;
     const void* pNext = {};
     uint64_t marker = {};
+
   };
   static_assert( sizeof( PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PerformanceMarkerInfoINTEL>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePerformanceMarkerInfoINTEL>
+  {
+    using Type = PerformanceMarkerInfoINTEL;
+  };
+
   struct PerformanceOverrideInfoINTEL
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceOverrideInfoINTEL;
+
     VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL type_ = VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL::eNullHardware,
                                                        VULKAN_HPP_NAMESPACE::Bool32 enable_ = {},
                                                        uint64_t parameter_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -45347,6 +49001,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPerformanceOverrideInfoINTEL const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceOverrideInfoINTEL*>( this );
@@ -45357,6 +49012,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceOverrideInfoINTEL*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PerformanceOverrideInfoINTEL const& ) const = default;
 #else
@@ -45375,18 +49031,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceOverrideInfoINTEL;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL::eNullHardware;
     VULKAN_HPP_NAMESPACE::Bool32 enable = {};
     uint64_t parameter = {};
+
   };
   static_assert( sizeof( PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PerformanceOverrideInfoINTEL>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePerformanceOverrideInfoINTEL>
+  {
+    using Type = PerformanceOverrideInfoINTEL;
+  };
+
   struct PerformanceQuerySubmitInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceQuerySubmitInfoKHR;
+
     VULKAN_HPP_CONSTEXPR PerformanceQuerySubmitInfoKHR( uint32_t counterPassIndex_ = {} ) VULKAN_HPP_NOEXCEPT
       : counterPassIndex( counterPassIndex_ )
     {}
@@ -45420,6 +49087,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPerformanceQuerySubmitInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>( this );
@@ -45430,6 +49098,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PerformanceQuerySubmitInfoKHR const& ) const = default;
 #else
@@ -45446,16 +49115,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceQuerySubmitInfoKHR;
     const void* pNext = {};
     uint32_t counterPassIndex = {};
+
   };
   static_assert( sizeof( PerformanceQuerySubmitInfoKHR ) == sizeof( VkPerformanceQuerySubmitInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PerformanceQuerySubmitInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePerformanceQuerySubmitInfoKHR>
+  {
+    using Type = PerformanceQuerySubmitInfoKHR;
+  };
+
   struct PerformanceStreamMarkerInfoINTEL
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceStreamMarkerInfoINTEL;
+
     VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = {} ) VULKAN_HPP_NOEXCEPT
       : marker( marker_ )
     {}
@@ -45489,6 +49169,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPerformanceStreamMarkerInfoINTEL const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL*>( this );
@@ -45499,6 +49180,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PerformanceStreamMarkerInfoINTEL const& ) const = default;
 #else
@@ -45515,14 +49197,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL;
     const void* pNext = {};
     uint32_t marker = {};
+
   };
   static_assert( sizeof( PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PerformanceStreamMarkerInfoINTEL>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePerformanceStreamMarkerInfoINTEL>
+  {
+    using Type = PerformanceStreamMarkerInfoINTEL;
+  };
+
   union PerformanceValueDataINTEL
   {
     PerformanceValueDataINTEL( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL const& rhs ) VULKAN_HPP_NOEXCEPT
@@ -45531,24 +49222,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     PerformanceValueDataINTEL( uint32_t value32_ = {} )
-    {
-      value32 = value32_;
-    }
+      : value32( value32_ )
+    {}
 
     PerformanceValueDataINTEL( uint64_t value64_ )
-    {
-      value64 = value64_;
-    }
+      : value64( value64_ )
+    {}
 
     PerformanceValueDataINTEL( float valueFloat_ )
-    {
-      valueFloat = valueFloat_;
-    }
+      : valueFloat( valueFloat_ )
+    {}
 
     PerformanceValueDataINTEL( const char* valueString_ )
-    {
-      valueString = valueString_;
-    }
+      : valueString( valueString_ )
+    {}
 
     PerformanceValueDataINTEL & setValue32( uint32_t value32_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -45613,6 +49300,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PerformanceValueINTEL
   {
+
     PerformanceValueINTEL( VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type_ = VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL::eUint32,
                            VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL data_ = {} ) VULKAN_HPP_NOEXCEPT
       : type( type_ )
@@ -45636,12 +49324,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PerformanceValueINTEL & setData( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL data_ ) VULKAN_HPP_NOEXCEPT
+    PerformanceValueINTEL & setData( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL const & data_ ) VULKAN_HPP_NOEXCEPT
     {
       data = data_;
       return *this;
     }
 
+
     operator VkPerformanceValueINTEL const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPerformanceValueINTEL*>( this );
@@ -45652,15 +49341,21 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceValueINTEL*>( this );
     }
 
+
+
+
   public:
     VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL::eUint32;
     VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL data = {};
+
   };
   static_assert( sizeof( PerformanceValueINTEL ) == sizeof( VkPerformanceValueINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PerformanceValueINTEL>::value, "struct wrapper is not a standard layout!" );
 
   struct PhysicalDevice16BitStorageFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevice16BitStorageFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( VULKAN_HPP_NAMESPACE::Bool32 storageBuffer16BitAccess_ = {},
                                                              VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer16BitAccess_ = {},
                                                              VULKAN_HPP_NAMESPACE::Bool32 storagePushConstant16_ = {},
@@ -45718,6 +49413,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDevice16BitStorageFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>( this );
@@ -45728,6 +49424,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDevice16BitStorageFeatures const& ) const = default;
 #else
@@ -45747,6 +49444,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures;
     void* pNext = {};
@@ -45754,12 +49453,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer16BitAccess = {};
     VULKAN_HPP_NAMESPACE::Bool32 storagePushConstant16 = {};
     VULKAN_HPP_NAMESPACE::Bool32 storageInputOutput16 = {};
+
   };
   static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevice16BitStorageFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDevice16BitStorageFeatures>
+  {
+    using Type = PhysicalDevice16BitStorageFeatures;
+  };
+
   struct PhysicalDevice8BitStorageFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevice8BitStorageFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeatures( VULKAN_HPP_NAMESPACE::Bool32 storageBuffer8BitAccess_ = {},
                                                             VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer8BitAccess_ = {},
                                                             VULKAN_HPP_NAMESPACE::Bool32 storagePushConstant8_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -45809,6 +49517,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDevice8BitStorageFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>( this );
@@ -45819,6 +49528,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDevice8BitStorageFeatures const& ) const = default;
 #else
@@ -45837,18 +49547,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevice8BitStorageFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 storageBuffer8BitAccess = {};
     VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer8BitAccess = {};
     VULKAN_HPP_NAMESPACE::Bool32 storagePushConstant8 = {};
+
   };
   static_assert( sizeof( PhysicalDevice8BitStorageFeatures ) == sizeof( VkPhysicalDevice8BitStorageFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevice8BitStorageFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDevice8BitStorageFeatures>
+  {
+    using Type = PhysicalDevice8BitStorageFeatures;
+  };
+
   struct PhysicalDeviceASTCDecodeFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 decodeModeSharedExponent_ = {} ) VULKAN_HPP_NOEXCEPT
       : decodeModeSharedExponent( decodeModeSharedExponent_ )
     {}
@@ -45882,6 +49603,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceASTCDecodeFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>( this );
@@ -45892,6 +49614,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceASTCDecodeFeaturesEXT const& ) const = default;
 #else
@@ -45908,16 +49631,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 decodeModeSharedExponent = {};
+
   };
   static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceASTCDecodeFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT>
+  {
+    using Type = PhysicalDeviceASTCDecodeFeaturesEXT;
+  };
+
   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 advancedBlendCoherentOperations_ = {} ) VULKAN_HPP_NOEXCEPT
       : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
     {}
@@ -45951,6 +49685,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>( this );
@@ -45961,6 +49696,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& ) const = default;
 #else
@@ -45977,16 +49713,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 advancedBlendCoherentOperations = {};
+
   };
   static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceBlendOperationAdvancedFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT>
+  {
+    using Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
+  };
+
   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedPropertiesEXT( uint32_t advancedBlendMaxColorAttachments_ = {},
                                                                             VULKAN_HPP_NAMESPACE::Bool32 advancedBlendIndependentBlend_ = {},
                                                                             VULKAN_HPP_NAMESPACE::Bool32 advancedBlendNonPremultipliedSrcColor_ = {},
@@ -46018,6 +49765,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>( this );
@@ -46028,6 +49776,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& ) const = default;
 #else
@@ -46049,6 +49798,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT;
     void* pNext = {};
@@ -46058,12 +49809,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 advancedBlendNonPremultipliedDstColor = {};
     VULKAN_HPP_NAMESPACE::Bool32 advancedBlendCorrelatedOverlap = {};
     VULKAN_HPP_NAMESPACE::Bool32 advancedBlendAllOperations = {};
+
   };
   static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceBlendOperationAdvancedPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT>
+  {
+    using Type = PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
+  };
+
   struct PhysicalDeviceBufferDeviceAddressFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBufferDeviceAddressFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeatures( VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddress_ = {},
                                                                     VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressCaptureReplay_ = {},
                                                                     VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressMultiDevice_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -46113,6 +49873,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceBufferDeviceAddressFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>( this );
@@ -46123,6 +49884,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceBufferDeviceAddressFeatures const& ) const = default;
 #else
@@ -46141,18 +49903,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddress = {};
     VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressCaptureReplay = {};
     VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressMultiDevice = {};
+
   };
   static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeatures ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceBufferDeviceAddressFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceBufferDeviceAddressFeatures>
+  {
+    using Type = PhysicalDeviceBufferDeviceAddressFeatures;
+  };
+
   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddress_ = {},
                                                                        VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressCaptureReplay_ = {},
                                                                        VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressMultiDevice_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -46202,6 +49975,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>( this );
@@ -46212,6 +49986,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceBufferDeviceAddressFeaturesEXT const& ) const = default;
 #else
@@ -46230,18 +50005,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddress = {};
     VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressCaptureReplay = {};
     VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressMultiDevice = {};
+
   };
   static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceBufferDeviceAddressFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT>
+  {
+    using Type = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
+  };
+
   struct PhysicalDeviceCoherentMemoryFeaturesAMD
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( VULKAN_HPP_NAMESPACE::Bool32 deviceCoherentMemory_ = {} ) VULKAN_HPP_NOEXCEPT
       : deviceCoherentMemory( deviceCoherentMemory_ )
     {}
@@ -46275,6 +50061,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>( this );
@@ -46285,6 +50072,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceCoherentMemoryFeaturesAMD const& ) const = default;
 #else
@@ -46301,16 +50089,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 deviceCoherentMemory = {};
+
   };
   static_assert( sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceCoherentMemoryFeaturesAMD>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD>
+  {
+    using Type = PhysicalDeviceCoherentMemoryFeaturesAMD;
+  };
+
   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 computeDerivativeGroupQuads_ = {},
                                                                            VULKAN_HPP_NAMESPACE::Bool32 computeDerivativeGroupLinear_ = {} ) VULKAN_HPP_NOEXCEPT
       : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
@@ -46352,6 +50151,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>( this );
@@ -46362,6 +50162,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& ) const = default;
 #else
@@ -46379,17 +50180,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 computeDerivativeGroupQuads = {};
     VULKAN_HPP_NAMESPACE::Bool32 computeDerivativeGroupLinear = {};
+
   };
   static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceComputeShaderDerivativesFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV>
+  {
+    using Type = PhysicalDeviceComputeShaderDerivativesFeaturesNV;
+  };
+
   struct PhysicalDeviceConditionalRenderingFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 conditionalRendering_ = {},
                                                                         VULKAN_HPP_NAMESPACE::Bool32 inheritedConditionalRendering_ = {} ) VULKAN_HPP_NOEXCEPT
       : conditionalRendering( conditionalRendering_ )
@@ -46431,6 +50243,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>( this );
@@ -46441,6 +50254,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceConditionalRenderingFeaturesEXT const& ) const = default;
 #else
@@ -46458,17 +50272,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 conditionalRendering = {};
     VULKAN_HPP_NAMESPACE::Bool32 inheritedConditionalRendering = {};
+
   };
   static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceConditionalRenderingFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT>
+  {
+    using Type = PhysicalDeviceConditionalRenderingFeaturesEXT;
+  };
+
   struct PhysicalDeviceConservativeRasterizationPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = {},
                                                                                float maxExtraPrimitiveOverestimationSize_ = {},
                                                                                float extraPrimitiveOverestimationSizeGranularity_ = {},
@@ -46506,6 +50331,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>( this );
@@ -46516,6 +50342,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceConservativeRasterizationPropertiesEXT const& ) const = default;
 #else
@@ -46540,6 +50367,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT;
     void* pNext = {};
@@ -46552,12 +50381,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 degenerateLinesRasterized = {};
     VULKAN_HPP_NAMESPACE::Bool32 fullyCoveredFragmentShaderInputVariable = {};
     VULKAN_HPP_NAMESPACE::Bool32 conservativeRasterizationPostDepthCoverage = {};
+
   };
   static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceConservativeRasterizationPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT>
+  {
+    using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT;
+  };
+
   struct PhysicalDeviceCooperativeMatrixFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrix_ = {},
                                                                     VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixRobustBufferAccess_ = {} ) VULKAN_HPP_NOEXCEPT
       : cooperativeMatrix( cooperativeMatrix_ )
@@ -46599,6 +50437,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>( this );
@@ -46609,6 +50448,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesNV const& ) const = default;
 #else
@@ -46626,17 +50466,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrix = {};
     VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixRobustBufferAccess = {};
+
   };
   static_assert( sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceCooperativeMatrixFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV>
+  {
+    using Type = PhysicalDeviceCooperativeMatrixFeaturesNV;
+  };
+
   struct PhysicalDeviceCooperativeMatrixPropertiesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesNV( VULKAN_HPP_NAMESPACE::ShaderStageFlags cooperativeMatrixSupportedStages_ = {} ) VULKAN_HPP_NOEXCEPT
       : cooperativeMatrixSupportedStages( cooperativeMatrixSupportedStages_ )
     {}
@@ -46658,6 +50509,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>( this );
@@ -46668,6 +50520,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesNV const& ) const = default;
 #else
@@ -46684,16 +50537,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ShaderStageFlags cooperativeMatrixSupportedStages = {};
+
   };
   static_assert( sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceCooperativeMatrixPropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV>
+  {
+    using Type = PhysicalDeviceCooperativeMatrixPropertiesNV;
+  };
+
   struct PhysicalDeviceCornerSampledImageFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 cornerSampledImage_ = {} ) VULKAN_HPP_NOEXCEPT
       : cornerSampledImage( cornerSampledImage_ )
     {}
@@ -46727,6 +50591,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceCornerSampledImageFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>( this );
@@ -46737,6 +50602,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceCornerSampledImageFeaturesNV const& ) const = default;
 #else
@@ -46753,16 +50619,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 cornerSampledImage = {};
+
   };
   static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceCornerSampledImageFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV>
+  {
+    using Type = PhysicalDeviceCornerSampledImageFeaturesNV;
+  };
+
   struct PhysicalDeviceCoverageReductionModeFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 coverageReductionMode_ = {} ) VULKAN_HPP_NOEXCEPT
       : coverageReductionMode( coverageReductionMode_ )
     {}
@@ -46796,6 +50673,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>( this );
@@ -46806,6 +50684,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceCoverageReductionModeFeaturesNV const& ) const = default;
 #else
@@ -46822,16 +50701,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 coverageReductionMode = {};
+
   };
   static_assert( sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) == sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceCoverageReductionModeFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV>
+  {
+    using Type = PhysicalDeviceCoverageReductionModeFeaturesNV;
+  };
+
   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocationImageAliasing_ = {} ) VULKAN_HPP_NOEXCEPT
       : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ )
     {}
@@ -46865,6 +50755,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>( this );
@@ -46875,6 +50766,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const& ) const = default;
 #else
@@ -46891,16 +50783,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocationImageAliasing = {};
+
   };
   static_assert( sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>
+  {
+    using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
+  };
+
   struct PhysicalDeviceDepthClipEnableFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable_ = {} ) VULKAN_HPP_NOEXCEPT
       : depthClipEnable( depthClipEnable_ )
     {}
@@ -46934,6 +50837,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>( this );
@@ -46944,6 +50848,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceDepthClipEnableFeaturesEXT const& ) const = default;
 #else
@@ -46960,16 +50865,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable = {};
+
   };
   static_assert( sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDepthClipEnableFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT>
+  {
+    using Type = PhysicalDeviceDepthClipEnableFeaturesEXT;
+  };
+
   struct PhysicalDeviceDepthStencilResolveProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthStencilResolveProperties;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthStencilResolveProperties( VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedDepthResolveModes_ = {},
                                                                       VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedStencilResolveModes_ = {},
                                                                       VULKAN_HPP_NAMESPACE::Bool32 independentResolveNone_ = {},
@@ -46997,6 +50913,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceDepthStencilResolveProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>( this );
@@ -47007,6 +50924,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceDepthStencilResolveProperties const& ) const = default;
 #else
@@ -47026,6 +50944,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolveProperties;
     void* pNext = {};
@@ -47033,12 +50953,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedStencilResolveModes = {};
     VULKAN_HPP_NAMESPACE::Bool32 independentResolveNone = {};
     VULKAN_HPP_NAMESPACE::Bool32 independentResolve = {};
+
   };
   static_assert( sizeof( PhysicalDeviceDepthStencilResolveProperties ) == sizeof( VkPhysicalDeviceDepthStencilResolveProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDepthStencilResolveProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDepthStencilResolveProperties>
+  {
+    using Type = PhysicalDeviceDepthStencilResolveProperties;
+  };
+
   struct PhysicalDeviceDescriptorIndexingFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorIndexingFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeatures( VULKAN_HPP_NAMESPACE::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = {},
                                                                    VULKAN_HPP_NAMESPACE::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = {},
                                                                    VULKAN_HPP_NAMESPACE::Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = {},
@@ -47224,6 +51153,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceDescriptorIndexingFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>( this );
@@ -47234,6 +51164,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceDescriptorIndexingFeatures const& ) const = default;
 #else
@@ -47269,6 +51200,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeatures;
     void* pNext = {};
@@ -47292,12 +51225,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 descriptorBindingPartiallyBound = {};
     VULKAN_HPP_NAMESPACE::Bool32 descriptorBindingVariableDescriptorCount = {};
     VULKAN_HPP_NAMESPACE::Bool32 runtimeDescriptorArray = {};
+
   };
   static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeatures ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDescriptorIndexingFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDescriptorIndexingFeatures>
+  {
+    using Type = PhysicalDeviceDescriptorIndexingFeatures;
+  };
+
   struct PhysicalDeviceDescriptorIndexingProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorIndexingProperties;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingProperties( uint32_t maxUpdateAfterBindDescriptorsInAllPools_ = {},
                                                                      VULKAN_HPP_NAMESPACE::Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ = {},
                                                                      VULKAN_HPP_NAMESPACE::Bool32 shaderSampledImageArrayNonUniformIndexingNative_ = {},
@@ -47363,6 +51305,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceDescriptorIndexingProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>( this );
@@ -47373,6 +51316,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceDescriptorIndexingProperties const& ) const = default;
 #else
@@ -47411,6 +51355,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingProperties;
     void* pNext = {};
@@ -47437,12 +51383,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t maxDescriptorSetUpdateAfterBindSampledImages = {};
     uint32_t maxDescriptorSetUpdateAfterBindStorageImages = {};
     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments = {};
+
   };
   static_assert( sizeof( PhysicalDeviceDescriptorIndexingProperties ) == sizeof( VkPhysicalDeviceDescriptorIndexingProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDescriptorIndexingProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDescriptorIndexingProperties>
+  {
+    using Type = PhysicalDeviceDescriptorIndexingProperties;
+  };
+
   struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 deviceGeneratedCommands_ = {} ) VULKAN_HPP_NOEXCEPT
       : deviceGeneratedCommands( deviceGeneratedCommands_ )
     {}
@@ -47476,6 +51431,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>( this );
@@ -47486,6 +51442,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const& ) const = default;
 #else
@@ -47502,16 +51459,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 deviceGeneratedCommands = {};
+
   };
   static_assert( sizeof( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV ) == sizeof( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV>
+  {
+    using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
+  };
+
   struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( uint32_t maxGraphicsShaderGroupCount_ = {},
                                                                             uint32_t maxIndirectSequenceCount_ = {},
                                                                             uint32_t maxIndirectCommandsTokenCount_ = {},
@@ -47549,6 +51517,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>( this );
@@ -47559,6 +51528,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const& ) const = default;
 #else
@@ -47583,6 +51553,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
     void* pNext = {};
@@ -47595,12 +51567,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t minSequencesCountBufferOffsetAlignment = {};
     uint32_t minSequencesIndexBufferOffsetAlignment = {};
     uint32_t minIndirectCommandsBufferOffsetAlignment = {};
+
   };
   static_assert( sizeof( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV ) == sizeof( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV>
+  {
+    using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
+  };
+
   struct PhysicalDeviceDiagnosticsConfigFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDiagnosticsConfigFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 diagnosticsConfig_ = {} ) VULKAN_HPP_NOEXCEPT
       : diagnosticsConfig( diagnosticsConfig_ )
     {}
@@ -47634,6 +51615,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>( this );
@@ -47644,6 +51626,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceDiagnosticsConfigFeaturesNV const& ) const = default;
 #else
@@ -47660,16 +51643,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 diagnosticsConfig = {};
+
   };
   static_assert( sizeof( PhysicalDeviceDiagnosticsConfigFeaturesNV ) == sizeof( VkPhysicalDeviceDiagnosticsConfigFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDiagnosticsConfigFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV>
+  {
+    using Type = PhysicalDeviceDiagnosticsConfigFeaturesNV;
+  };
+
   struct PhysicalDeviceDiscardRectanglePropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = {} ) VULKAN_HPP_NOEXCEPT
       : maxDiscardRectangles( maxDiscardRectangles_ )
     {}
@@ -47691,6 +51685,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>( this );
@@ -47701,6 +51696,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceDiscardRectanglePropertiesEXT const& ) const = default;
 #else
@@ -47717,16 +51713,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
     void* pNext = {};
     uint32_t maxDiscardRectangles = {};
+
   };
   static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDiscardRectanglePropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT>
+  {
+    using Type = PhysicalDeviceDiscardRectanglePropertiesEXT;
+  };
+
   struct PhysicalDeviceDriverProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDriverProperties;
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDriverProperties( VULKAN_HPP_NAMESPACE::DriverId driverID_ = VULKAN_HPP_NAMESPACE::DriverId::eAmdProprietary,
                                                             std::array<char,VK_MAX_DRIVER_NAME_SIZE> const& driverName_ = {},
                                                             std::array<char,VK_MAX_DRIVER_INFO_SIZE> const& driverInfo_ = {},
@@ -47754,6 +51761,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceDriverProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceDriverProperties*>( this );
@@ -47764,6 +51772,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDriverProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceDriverProperties const& ) const = default;
 #else
@@ -47783,6 +51792,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDriverProperties;
     void* pNext = {};
@@ -47790,12 +51801,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_NAME_SIZE> driverName = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_INFO_SIZE> driverInfo = {};
     VULKAN_HPP_NAMESPACE::ConformanceVersion conformanceVersion = {};
+
   };
   static_assert( sizeof( PhysicalDeviceDriverProperties ) == sizeof( VkPhysicalDeviceDriverProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDriverProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDriverProperties>
+  {
+    using Type = PhysicalDeviceDriverProperties;
+  };
+
   struct PhysicalDeviceExclusiveScissorFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 exclusiveScissor_ = {} ) VULKAN_HPP_NOEXCEPT
       : exclusiveScissor( exclusiveScissor_ )
     {}
@@ -47829,6 +51849,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceExclusiveScissorFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>( this );
@@ -47839,6 +51860,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceExclusiveScissorFeaturesNV const& ) const = default;
 #else
@@ -47855,16 +51877,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 exclusiveScissor = {};
+
   };
   static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceExclusiveScissorFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV>
+  {
+    using Type = PhysicalDeviceExclusiveScissorFeaturesNV;
+  };
+
   struct PhysicalDeviceExternalBufferInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalBufferInfo;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( VULKAN_HPP_NAMESPACE::BufferCreateFlags flags_ = {},
                                                            VULKAN_HPP_NAMESPACE::BufferUsageFlags usage_ = {},
                                                            VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
@@ -47914,6 +51947,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceExternalBufferInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( this );
@@ -47924,6 +51958,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceExternalBufferInfo const& ) const = default;
 #else
@@ -47942,18 +51977,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::BufferCreateFlags flags = {};
     VULKAN_HPP_NAMESPACE::BufferUsageFlags usage = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd;
+
   };
   static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceExternalBufferInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceExternalBufferInfo>
+  {
+    using Type = PhysicalDeviceExternalBufferInfo;
+  };
+
   struct PhysicalDeviceExternalFenceInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalFenceInfo;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
       : handleType( handleType_ )
     {}
@@ -47987,6 +52033,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceExternalFenceInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( this );
@@ -47997,6 +52044,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceExternalFenceInfo const& ) const = default;
 #else
@@ -48013,16 +52061,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd;
+
   };
   static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceExternalFenceInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceExternalFenceInfo>
+  {
+    using Type = PhysicalDeviceExternalFenceInfo;
+  };
+
   struct PhysicalDeviceExternalImageFormatInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalImageFormatInfo;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
       : handleType( handleType_ )
     {}
@@ -48056,6 +52115,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceExternalImageFormatInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>( this );
@@ -48066,6 +52126,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceExternalImageFormatInfo const& ) const = default;
 #else
@@ -48082,16 +52143,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd;
+
   };
   static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceExternalImageFormatInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceExternalImageFormatInfo>
+  {
+    using Type = PhysicalDeviceExternalImageFormatInfo;
+  };
+
   struct PhysicalDeviceExternalMemoryHostPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryHostPropertiesEXT( VULKAN_HPP_NAMESPACE::DeviceSize minImportedHostPointerAlignment_ = {} ) VULKAN_HPP_NOEXCEPT
       : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
     {}
@@ -48113,6 +52185,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>( this );
@@ -48123,6 +52196,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceExternalMemoryHostPropertiesEXT const& ) const = default;
 #else
@@ -48139,16 +52213,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::DeviceSize minImportedHostPointerAlignment = {};
+
   };
   static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceExternalMemoryHostPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT>
+  {
+    using Type = PhysicalDeviceExternalMemoryHostPropertiesEXT;
+  };
+
   struct PhysicalDeviceExternalSemaphoreInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalSemaphoreInfo;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
       : handleType( handleType_ )
     {}
@@ -48182,6 +52267,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceExternalSemaphoreInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( this );
@@ -48192,6 +52278,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceExternalSemaphoreInfo const& ) const = default;
 #else
@@ -48208,16 +52295,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd;
+
   };
   static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceExternalSemaphoreInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceExternalSemaphoreInfo>
+  {
+    using Type = PhysicalDeviceExternalSemaphoreInfo;
+  };
+
   struct PhysicalDeviceFeatures2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFeatures2;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features_ = {} ) VULKAN_HPP_NOEXCEPT
       : features( features_ )
     {}
@@ -48245,12 +52343,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceFeatures2 & setFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features_ ) VULKAN_HPP_NOEXCEPT
+    PhysicalDeviceFeatures2 & setFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & features_ ) VULKAN_HPP_NOEXCEPT
     {
       features = features_;
       return *this;
     }
 
+
     operator VkPhysicalDeviceFeatures2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFeatures2*>( this );
@@ -48261,6 +52360,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFeatures2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceFeatures2 const& ) const = default;
 #else
@@ -48277,16 +52377,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFeatures2;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features = {};
+
   };
   static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFeatures2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceFeatures2>
+  {
+    using Type = PhysicalDeviceFeatures2;
+  };
+
   struct PhysicalDeviceFloatControlsProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFloatControlsProperties;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceFloatControlsProperties( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence denormBehaviorIndependence_ = VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence::e32BitOnly,
                                                                 VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence roundingModeIndependence_ = VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence::e32BitOnly,
                                                                 VULKAN_HPP_NAMESPACE::Bool32 shaderSignedZeroInfNanPreserveFloat16_ = {},
@@ -48340,6 +52451,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceFloatControlsProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>( this );
@@ -48350,6 +52462,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceFloatControlsProperties const& ) const = default;
 #else
@@ -48382,6 +52495,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFloatControlsProperties;
     void* pNext = {};
@@ -48402,12 +52517,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat16 = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat32 = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat64 = {};
+
   };
   static_assert( sizeof( PhysicalDeviceFloatControlsProperties ) == sizeof( VkPhysicalDeviceFloatControlsProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFloatControlsProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceFloatControlsProperties>
+  {
+    using Type = PhysicalDeviceFloatControlsProperties;
+  };
+
   struct PhysicalDeviceFragmentDensityMapFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMap_ = {},
                                                                       VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapDynamic_ = {},
                                                                       VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapNonSubsampledImages_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -48433,6 +52557,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>( this );
@@ -48443,6 +52568,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceFragmentDensityMapFeaturesEXT const& ) const = default;
 #else
@@ -48461,18 +52587,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMap = {};
     VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapDynamic = {};
     VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapNonSubsampledImages = {};
+
   };
   static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFragmentDensityMapFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT>
+  {
+    using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT;
+  };
+
   struct PhysicalDeviceFragmentDensityMapPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapPropertiesEXT( VULKAN_HPP_NAMESPACE::Extent2D minFragmentDensityTexelSize_ = {},
                                                                         VULKAN_HPP_NAMESPACE::Extent2D maxFragmentDensityTexelSize_ = {},
                                                                         VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityInvocations_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -48498,6 +52635,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>( this );
@@ -48508,6 +52646,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceFragmentDensityMapPropertiesEXT const& ) const = default;
 #else
@@ -48526,18 +52665,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Extent2D minFragmentDensityTexelSize = {};
     VULKAN_HPP_NAMESPACE::Extent2D maxFragmentDensityTexelSize = {};
     VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityInvocations = {};
+
   };
   static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFragmentDensityMapPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT>
+  {
+    using Type = PhysicalDeviceFragmentDensityMapPropertiesEXT;
+  };
+
   struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderBarycentric_ = {} ) VULKAN_HPP_NOEXCEPT
       : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
     {}
@@ -48571,6 +52721,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>( this );
@@ -48581,6 +52732,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& ) const = default;
 #else
@@ -48597,16 +52749,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderBarycentric = {};
+
   };
   static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFragmentShaderBarycentricFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV>
+  {
+    using Type = PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
+  };
+
   struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderSampleInterlock_ = {},
                                                                            VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderPixelInterlock_ = {},
                                                                            VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderShadingRateInterlock_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -48656,6 +52819,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>( this );
@@ -48666,6 +52830,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const& ) const = default;
 #else
@@ -48684,18 +52849,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderSampleInterlock = {};
     VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderPixelInterlock = {};
     VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderShadingRateInterlock = {};
+
   };
   static_assert( sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFragmentShaderInterlockFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT>
+  {
+    using Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
+  };
+
   struct PhysicalDeviceGroupProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGroupProperties;
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGroupProperties( uint32_t physicalDeviceCount_ = {},
                                                            std::array<VULKAN_HPP_NAMESPACE::PhysicalDevice,VK_MAX_DEVICE_GROUP_SIZE> const& physicalDevices_ = {},
                                                            VULKAN_HPP_NAMESPACE::Bool32 subsetAllocation_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -48721,6 +52897,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceGroupProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceGroupProperties*>( this );
@@ -48731,6 +52908,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceGroupProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceGroupProperties const& ) const = default;
 #else
@@ -48749,18 +52927,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceGroupProperties;
     void* pNext = {};
     uint32_t physicalDeviceCount = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::PhysicalDevice, VK_MAX_DEVICE_GROUP_SIZE> physicalDevices = {};
     VULKAN_HPP_NAMESPACE::Bool32 subsetAllocation = {};
+
   };
   static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceGroupProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceGroupProperties>
+  {
+    using Type = PhysicalDeviceGroupProperties;
+  };
+
   struct PhysicalDeviceHostQueryResetFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceHostQueryResetFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeatures( VULKAN_HPP_NAMESPACE::Bool32 hostQueryReset_ = {} ) VULKAN_HPP_NOEXCEPT
       : hostQueryReset( hostQueryReset_ )
     {}
@@ -48794,6 +52983,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceHostQueryResetFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>( this );
@@ -48804,6 +52994,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceHostQueryResetFeatures const& ) const = default;
 #else
@@ -48820,16 +53011,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 hostQueryReset = {};
+
   };
   static_assert( sizeof( PhysicalDeviceHostQueryResetFeatures ) == sizeof( VkPhysicalDeviceHostQueryResetFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceHostQueryResetFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceHostQueryResetFeatures>
+  {
+    using Type = PhysicalDeviceHostQueryResetFeatures;
+  };
+
   struct PhysicalDeviceIDProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceIdProperties;
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIDProperties( std::array<uint8_t,VK_UUID_SIZE> const& deviceUUID_ = {},
                                                         std::array<uint8_t,VK_UUID_SIZE> const& driverUUID_ = {},
                                                         std::array<uint8_t,VK_LUID_SIZE> const& deviceLUID_ = {},
@@ -48859,6 +53061,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceIDProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceIDProperties*>( this );
@@ -48869,6 +53072,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceIDProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceIDProperties const& ) const = default;
 #else
@@ -48889,6 +53093,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceIdProperties;
     void* pNext = {};
@@ -48897,12 +53103,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_LUID_SIZE> deviceLUID = {};
     uint32_t deviceNodeMask = {};
     VULKAN_HPP_NAMESPACE::Bool32 deviceLUIDValid = {};
+
   };
   static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceIDProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceIdProperties>
+  {
+    using Type = PhysicalDeviceIDProperties;
+  };
+
   struct PhysicalDeviceImageDrmFormatModifierInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = {},
                                                                       VULKAN_HPP_NAMESPACE::SharingMode sharingMode_ = VULKAN_HPP_NAMESPACE::SharingMode::eExclusive,
                                                                       uint32_t queueFamilyIndexCount_ = {},
@@ -48960,6 +53175,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>( this );
@@ -48970,6 +53186,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceImageDrmFormatModifierInfoEXT const& ) const = default;
 #else
@@ -48989,6 +53206,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT;
     const void* pNext = {};
@@ -48996,12 +53215,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::SharingMode sharingMode = VULKAN_HPP_NAMESPACE::SharingMode::eExclusive;
     uint32_t queueFamilyIndexCount = {};
     const uint32_t* pQueueFamilyIndices = {};
+
   };
   static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceImageDrmFormatModifierInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT>
+  {
+    using Type = PhysicalDeviceImageDrmFormatModifierInfoEXT;
+  };
+
   struct PhysicalDeviceImageFormatInfo2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageFormatInfo2;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
                                                          VULKAN_HPP_NAMESPACE::ImageType type_ = VULKAN_HPP_NAMESPACE::ImageType::e1D,
                                                          VULKAN_HPP_NAMESPACE::ImageTiling tiling_ = VULKAN_HPP_NAMESPACE::ImageTiling::eOptimal,
@@ -49067,6 +53295,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceImageFormatInfo2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( this );
@@ -49077,6 +53306,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceImageFormatInfo2 const& ) const = default;
 #else
@@ -49097,6 +53327,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2;
     const void* pNext = {};
@@ -49105,12 +53337,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ImageTiling tiling = VULKAN_HPP_NAMESPACE::ImageTiling::eOptimal;
     VULKAN_HPP_NAMESPACE::ImageUsageFlags usage = {};
     VULKAN_HPP_NAMESPACE::ImageCreateFlags flags = {};
+
   };
   static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceImageFormatInfo2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceImageFormatInfo2>
+  {
+    using Type = PhysicalDeviceImageFormatInfo2;
+  };
+
   struct PhysicalDeviceImageViewImageFormatInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( VULKAN_HPP_NAMESPACE::ImageViewType imageViewType_ = VULKAN_HPP_NAMESPACE::ImageViewType::e1D ) VULKAN_HPP_NOEXCEPT
       : imageViewType( imageViewType_ )
     {}
@@ -49144,6 +53385,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceImageViewImageFormatInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>( this );
@@ -49154,6 +53396,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceImageViewImageFormatInfoEXT const& ) const = default;
 #else
@@ -49170,16 +53413,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ImageViewType imageViewType = VULKAN_HPP_NAMESPACE::ImageViewType::e1D;
+
   };
   static_assert( sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceImageViewImageFormatInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT>
+  {
+    using Type = PhysicalDeviceImageViewImageFormatInfoEXT;
+  };
+
   struct PhysicalDeviceImagelessFramebufferFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImagelessFramebufferFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeatures( VULKAN_HPP_NAMESPACE::Bool32 imagelessFramebuffer_ = {} ) VULKAN_HPP_NOEXCEPT
       : imagelessFramebuffer( imagelessFramebuffer_ )
     {}
@@ -49213,6 +53467,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceImagelessFramebufferFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>( this );
@@ -49223,6 +53478,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceImagelessFramebufferFeatures const& ) const = default;
 #else
@@ -49239,16 +53495,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 imagelessFramebuffer = {};
+
   };
   static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeatures ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceImagelessFramebufferFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceImagelessFramebufferFeatures>
+  {
+    using Type = PhysicalDeviceImagelessFramebufferFeatures;
+  };
+
   struct PhysicalDeviceIndexTypeUint8FeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 indexTypeUint8_ = {} ) VULKAN_HPP_NOEXCEPT
       : indexTypeUint8( indexTypeUint8_ )
     {}
@@ -49282,6 +53549,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>( this );
@@ -49292,6 +53560,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceIndexTypeUint8FeaturesEXT const& ) const = default;
 #else
@@ -49308,16 +53577,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 indexTypeUint8 = {};
+
   };
   static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceIndexTypeUint8FeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT>
+  {
+    using Type = PhysicalDeviceIndexTypeUint8FeaturesEXT;
+  };
+
   struct PhysicalDeviceInlineUniformBlockFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 inlineUniformBlock_ = {},
                                                                       VULKAN_HPP_NAMESPACE::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = {} ) VULKAN_HPP_NOEXCEPT
       : inlineUniformBlock( inlineUniformBlock_ )
@@ -49359,6 +53639,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>( this );
@@ -49369,6 +53650,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceInlineUniformBlockFeaturesEXT const& ) const = default;
 #else
@@ -49386,17 +53668,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 inlineUniformBlock = {};
     VULKAN_HPP_NAMESPACE::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind = {};
+
   };
   static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceInlineUniformBlockFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT>
+  {
+    using Type = PhysicalDeviceInlineUniformBlockFeaturesEXT;
+  };
+
   struct PhysicalDeviceInlineUniformBlockPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockPropertiesEXT( uint32_t maxInlineUniformBlockSize_ = {},
                                                                         uint32_t maxPerStageDescriptorInlineUniformBlocks_ = {},
                                                                         uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ = {},
@@ -49426,6 +53719,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>( this );
@@ -49436,6 +53730,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceInlineUniformBlockPropertiesEXT const& ) const = default;
 #else
@@ -49456,6 +53751,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT;
     void* pNext = {};
@@ -49464,12 +53761,20 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = {};
     uint32_t maxDescriptorSetInlineUniformBlocks = {};
     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks = {};
+
   };
   static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceInlineUniformBlockPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT>
+  {
+    using Type = PhysicalDeviceInlineUniformBlockPropertiesEXT;
+  };
+
   struct PhysicalDeviceLimits
   {
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLimits( uint32_t maxImageDimension1D_ = {},
                                                   uint32_t maxImageDimension2D_ = {},
                                                   uint32_t maxImageDimension3D_ = {},
@@ -49695,6 +54000,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceLimits const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceLimits*>( this );
@@ -49705,6 +54011,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceLimits*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceLimits const& ) const = default;
 #else
@@ -49824,6 +54131,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t maxImageDimension1D = {};
     uint32_t maxImageDimension2D = {};
@@ -49931,12 +54240,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeviceSize optimalBufferCopyOffsetAlignment = {};
     VULKAN_HPP_NAMESPACE::DeviceSize optimalBufferCopyRowPitchAlignment = {};
     VULKAN_HPP_NAMESPACE::DeviceSize nonCoherentAtomSize = {};
+
   };
   static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceLimits>::value, "struct wrapper is not a standard layout!" );
 
   struct PhysicalDeviceLineRasterizationFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 rectangularLines_ = {},
                                                                      VULKAN_HPP_NAMESPACE::Bool32 bresenhamLines_ = {},
                                                                      VULKAN_HPP_NAMESPACE::Bool32 smoothLines_ = {},
@@ -50010,6 +54322,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceLineRasterizationFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>( this );
@@ -50020,6 +54333,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceLineRasterizationFeaturesEXT const& ) const = default;
 #else
@@ -50041,6 +54355,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT;
     void* pNext = {};
@@ -50050,12 +54366,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 stippledRectangularLines = {};
     VULKAN_HPP_NAMESPACE::Bool32 stippledBresenhamLines = {};
     VULKAN_HPP_NAMESPACE::Bool32 stippledSmoothLines = {};
+
   };
   static_assert( sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceLineRasterizationFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT>
+  {
+    using Type = PhysicalDeviceLineRasterizationFeaturesEXT;
+  };
+
   struct PhysicalDeviceLineRasterizationPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationPropertiesEXT( uint32_t lineSubPixelPrecisionBits_ = {} ) VULKAN_HPP_NOEXCEPT
       : lineSubPixelPrecisionBits( lineSubPixelPrecisionBits_ )
     {}
@@ -50077,6 +54402,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceLineRasterizationPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>( this );
@@ -50087,6 +54413,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceLineRasterizationPropertiesEXT const& ) const = default;
 #else
@@ -50103,16 +54430,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT;
     void* pNext = {};
     uint32_t lineSubPixelPrecisionBits = {};
+
   };
   static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceLineRasterizationPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT>
+  {
+    using Type = PhysicalDeviceLineRasterizationPropertiesEXT;
+  };
+
   struct PhysicalDeviceMaintenance3Properties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance3Properties;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance3Properties( uint32_t maxPerSetDescriptors_ = {},
                                                                VULKAN_HPP_NAMESPACE::DeviceSize maxMemoryAllocationSize_ = {} ) VULKAN_HPP_NOEXCEPT
       : maxPerSetDescriptors( maxPerSetDescriptors_ )
@@ -50136,6 +54474,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceMaintenance3Properties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>( this );
@@ -50146,6 +54485,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceMaintenance3Properties const& ) const = default;
 #else
@@ -50163,17 +54503,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties;
     void* pNext = {};
     uint32_t maxPerSetDescriptors = {};
     VULKAN_HPP_NAMESPACE::DeviceSize maxMemoryAllocationSize = {};
+
   };
   static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMaintenance3Properties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceMaintenance3Properties>
+  {
+    using Type = PhysicalDeviceMaintenance3Properties;
+  };
+
   struct PhysicalDeviceMemoryBudgetPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryBudgetPropertiesEXT( std::array<VULKAN_HPP_NAMESPACE::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapBudget_ = {},
                                                                      std::array<VULKAN_HPP_NAMESPACE::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapUsage_ = {} ) VULKAN_HPP_NOEXCEPT
       : heapBudget( heapBudget_ )
@@ -50197,6 +54548,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>( this );
@@ -50207,6 +54559,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceMemoryBudgetPropertiesEXT const& ) const = default;
 #else
@@ -50224,17 +54577,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> heapBudget = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> heapUsage = {};
+
   };
   static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMemoryBudgetPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT>
+  {
+    using Type = PhysicalDeviceMemoryBudgetPropertiesEXT;
+  };
+
   struct PhysicalDeviceMemoryPriorityFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 memoryPriority_ = {} ) VULKAN_HPP_NOEXCEPT
       : memoryPriority( memoryPriority_ )
     {}
@@ -50268,6 +54632,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>( this );
@@ -50278,6 +54643,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceMemoryPriorityFeaturesEXT const& ) const = default;
 #else
@@ -50294,16 +54660,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 memoryPriority = {};
+
   };
   static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMemoryPriorityFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT>
+  {
+    using Type = PhysicalDeviceMemoryPriorityFeaturesEXT;
+  };
+
   struct PhysicalDeviceMemoryProperties
   {
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties( uint32_t memoryTypeCount_ = {},
                                                             std::array<VULKAN_HPP_NAMESPACE::MemoryType,VK_MAX_MEMORY_TYPES> const& memoryTypes_ = {},
                                                             uint32_t memoryHeapCount_ = {},
@@ -50325,6 +54701,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceMemoryProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>( this );
@@ -50335,6 +54712,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceMemoryProperties const& ) const = default;
 #else
@@ -50352,17 +54730,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t memoryTypeCount = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryType, VK_MAX_MEMORY_TYPES> memoryTypes = {};
     uint32_t memoryHeapCount = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryHeap, VK_MAX_MEMORY_HEAPS> memoryHeaps = {};
+
   };
   static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMemoryProperties>::value, "struct wrapper is not a standard layout!" );
 
   struct PhysicalDeviceMemoryProperties2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryProperties2;
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties_ = {} ) VULKAN_HPP_NOEXCEPT
       : memoryProperties( memoryProperties_ )
     {}
@@ -50384,6 +54767,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceMemoryProperties2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>( this );
@@ -50394,6 +54778,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceMemoryProperties2 const& ) const = default;
 #else
@@ -50410,16 +54795,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties = {};
+
   };
   static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMemoryProperties2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceMemoryProperties2>
+  {
+    using Type = PhysicalDeviceMemoryProperties2;
+  };
+
   struct PhysicalDeviceMeshShaderFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 taskShader_ = {},
                                                              VULKAN_HPP_NAMESPACE::Bool32 meshShader_ = {} ) VULKAN_HPP_NOEXCEPT
       : taskShader( taskShader_ )
@@ -50461,6 +54857,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceMeshShaderFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>( this );
@@ -50471,6 +54868,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceMeshShaderFeaturesNV const& ) const = default;
 #else
@@ -50488,17 +54886,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 taskShader = {};
     VULKAN_HPP_NAMESPACE::Bool32 meshShader = {};
+
   };
   static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMeshShaderFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceMeshShaderFeaturesNV>
+  {
+    using Type = PhysicalDeviceMeshShaderFeaturesNV;
+  };
+
   struct PhysicalDeviceMeshShaderPropertiesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV;
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = {},
                                                                   uint32_t maxTaskWorkGroupInvocations_ = {},
                                                                   std::array<uint32_t,3> const& maxTaskWorkGroupSize_ = {},
@@ -50544,6 +54953,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceMeshShaderPropertiesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>( this );
@@ -50554,6 +54964,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceMeshShaderPropertiesNV const& ) const = default;
 #else
@@ -50582,6 +54993,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV;
     void* pNext = {};
@@ -50598,12 +55011,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t maxMeshMultiviewViewCount = {};
     uint32_t meshOutputPerVertexGranularity = {};
     uint32_t meshOutputPerPrimitiveGranularity = {};
+
   };
   static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMeshShaderPropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceMeshShaderPropertiesNV>
+  {
+    using Type = PhysicalDeviceMeshShaderPropertiesNV;
+  };
+
   struct PhysicalDeviceMultiviewFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( VULKAN_HPP_NAMESPACE::Bool32 multiview_ = {},
                                                           VULKAN_HPP_NAMESPACE::Bool32 multiviewGeometryShader_ = {},
                                                           VULKAN_HPP_NAMESPACE::Bool32 multiviewTessellationShader_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -50653,6 +55075,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceMultiviewFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>( this );
@@ -50663,6 +55086,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceMultiviewFeatures const& ) const = default;
 #else
@@ -50681,18 +55105,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 multiview = {};
     VULKAN_HPP_NAMESPACE::Bool32 multiviewGeometryShader = {};
     VULKAN_HPP_NAMESPACE::Bool32 multiviewTessellationShader = {};
+
   };
   static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMultiviewFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceMultiviewFeatures>
+  {
+    using Type = PhysicalDeviceMultiviewFeatures;
+  };
+
   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VULKAN_HPP_NAMESPACE::Bool32 perViewPositionAllComponents_ = {} ) VULKAN_HPP_NOEXCEPT
       : perViewPositionAllComponents( perViewPositionAllComponents_ )
     {}
@@ -50714,6 +55149,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>( this );
@@ -50724,6 +55160,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& ) const = default;
 #else
@@ -50740,16 +55177,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 perViewPositionAllComponents = {};
+
   };
   static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>
+  {
+    using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
+  };
+
   struct PhysicalDeviceMultiviewProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewProperties;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewProperties( uint32_t maxMultiviewViewCount_ = {},
                                                             uint32_t maxMultiviewInstanceIndex_ = {} ) VULKAN_HPP_NOEXCEPT
       : maxMultiviewViewCount( maxMultiviewViewCount_ )
@@ -50773,6 +55221,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceMultiviewProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>( this );
@@ -50783,6 +55232,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceMultiviewProperties const& ) const = default;
 #else
@@ -50800,17 +55250,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties;
     void* pNext = {};
     uint32_t maxMultiviewViewCount = {};
     uint32_t maxMultiviewInstanceIndex = {};
+
   };
   static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMultiviewProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceMultiviewProperties>
+  {
+    using Type = PhysicalDeviceMultiviewProperties;
+  };
+
   struct PhysicalDevicePCIBusInfoPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDevicePCIBusInfoPropertiesEXT( uint32_t pciDomain_ = {},
                                                                 uint32_t pciBus_ = {},
                                                                 uint32_t pciDevice_ = {},
@@ -50838,6 +55299,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDevicePCIBusInfoPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>( this );
@@ -50848,6 +55310,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDevicePCIBusInfoPropertiesEXT const& ) const = default;
 #else
@@ -50867,6 +55330,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT;
     void* pNext = {};
@@ -50874,12 +55339,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t pciBus = {};
     uint32_t pciDevice = {};
     uint32_t pciFunction = {};
+
   };
   static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevicePCIBusInfoPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDevicePciBusInfoPropertiesEXT>
+  {
+    using Type = PhysicalDevicePCIBusInfoPropertiesEXT;
+  };
+
   struct PhysicalDevicePerformanceQueryFeaturesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR;
+
     VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 performanceCounterQueryPools_ = {},
                                                                     VULKAN_HPP_NAMESPACE::Bool32 performanceCounterMultipleQueryPools_ = {} ) VULKAN_HPP_NOEXCEPT
       : performanceCounterQueryPools( performanceCounterQueryPools_ )
@@ -50921,6 +55395,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDevicePerformanceQueryFeaturesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>( this );
@@ -50931,6 +55406,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDevicePerformanceQueryFeaturesKHR const& ) const = default;
 #else
@@ -50948,17 +55424,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 performanceCounterQueryPools = {};
     VULKAN_HPP_NAMESPACE::Bool32 performanceCounterMultipleQueryPools = {};
+
   };
   static_assert( sizeof( PhysicalDevicePerformanceQueryFeaturesKHR ) == sizeof( VkPhysicalDevicePerformanceQueryFeaturesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevicePerformanceQueryFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR>
+  {
+    using Type = PhysicalDevicePerformanceQueryFeaturesKHR;
+  };
+
   struct PhysicalDevicePerformanceQueryPropertiesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR;
+
     VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryPropertiesKHR( VULKAN_HPP_NAMESPACE::Bool32 allowCommandBufferQueryCopies_ = {} ) VULKAN_HPP_NOEXCEPT
       : allowCommandBufferQueryCopies( allowCommandBufferQueryCopies_ )
     {}
@@ -50980,6 +55467,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDevicePerformanceQueryPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>( this );
@@ -50990,6 +55478,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDevicePerformanceQueryPropertiesKHR const& ) const = default;
 #else
@@ -51006,16 +55495,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 allowCommandBufferQueryCopies = {};
+
   };
   static_assert( sizeof( PhysicalDevicePerformanceQueryPropertiesKHR ) == sizeof( VkPhysicalDevicePerformanceQueryPropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevicePerformanceQueryPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR>
+  {
+    using Type = PhysicalDevicePerformanceQueryPropertiesKHR;
+  };
+
   struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineCreationCacheControlFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineCreationCacheControlFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 pipelineCreationCacheControl_ = {} ) VULKAN_HPP_NOEXCEPT
       : pipelineCreationCacheControl( pipelineCreationCacheControl_ )
     {}
@@ -51049,6 +55549,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>( this );
@@ -51059,6 +55560,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const& ) const = default;
 #else
@@ -51075,16 +55577,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePipelineCreationCacheControlFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 pipelineCreationCacheControl = {};
+
   };
   static_assert( sizeof( PhysicalDevicePipelineCreationCacheControlFeaturesEXT ) == sizeof( VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevicePipelineCreationCacheControlFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDevicePipelineCreationCacheControlFeaturesEXT>
+  {
+    using Type = PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
+  };
+
   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
+
     VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 pipelineExecutableInfo_ = {} ) VULKAN_HPP_NOEXCEPT
       : pipelineExecutableInfo( pipelineExecutableInfo_ )
     {}
@@ -51118,6 +55631,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>( this );
@@ -51128,6 +55642,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const& ) const = default;
 #else
@@ -51144,16 +55659,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 pipelineExecutableInfo = {};
+
   };
   static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR>
+  {
+    using Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
+  };
+
   struct PhysicalDevicePointClippingProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePointClippingProperties;
+
     VULKAN_HPP_CONSTEXPR PhysicalDevicePointClippingProperties( VULKAN_HPP_NAMESPACE::PointClippingBehavior pointClippingBehavior_ = VULKAN_HPP_NAMESPACE::PointClippingBehavior::eAllClipPlanes ) VULKAN_HPP_NOEXCEPT
       : pointClippingBehavior( pointClippingBehavior_ )
     {}
@@ -51175,6 +55701,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDevicePointClippingProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>( this );
@@ -51185,6 +55712,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDevicePointClippingProperties const& ) const = default;
 #else
@@ -51201,16 +55729,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePointClippingProperties;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::PointClippingBehavior pointClippingBehavior = VULKAN_HPP_NAMESPACE::PointClippingBehavior::eAllClipPlanes;
+
   };
   static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevicePointClippingProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDevicePointClippingProperties>
+  {
+    using Type = PhysicalDevicePointClippingProperties;
+  };
+
   struct PhysicalDeviceSparseProperties
   {
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseProperties( VULKAN_HPP_NAMESPACE::Bool32 residencyStandard2DBlockShape_ = {},
                                                          VULKAN_HPP_NAMESPACE::Bool32 residencyStandard2DMultisampleBlockShape_ = {},
                                                          VULKAN_HPP_NAMESPACE::Bool32 residencyStandard3DBlockShape_ = {},
@@ -51234,6 +55772,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceSparseProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>( this );
@@ -51244,6 +55783,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSparseProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceSparseProperties const& ) const = default;
 #else
@@ -51262,18 +55802,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Bool32 residencyStandard2DBlockShape = {};
     VULKAN_HPP_NAMESPACE::Bool32 residencyStandard2DMultisampleBlockShape = {};
     VULKAN_HPP_NAMESPACE::Bool32 residencyStandard3DBlockShape = {};
     VULKAN_HPP_NAMESPACE::Bool32 residencyAlignedMipSize = {};
     VULKAN_HPP_NAMESPACE::Bool32 residencyNonResidentStrict = {};
+
   };
   static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSparseProperties>::value, "struct wrapper is not a standard layout!" );
 
   struct PhysicalDeviceProperties
   {
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties( uint32_t apiVersion_ = {},
                                                       uint32_t driverVersion_ = {},
                                                       uint32_t vendorID_ = {},
@@ -51305,6 +55849,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceProperties*>( this );
@@ -51315,6 +55860,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceProperties const& ) const = default;
 #else
@@ -51337,6 +55883,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t apiVersion = {};
     uint32_t driverVersion = {};
@@ -51347,12 +55895,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> pipelineCacheUUID = {};
     VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits limits = {};
     VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties sparseProperties = {};
+
   };
   static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceProperties>::value, "struct wrapper is not a standard layout!" );
 
   struct PhysicalDeviceProperties2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProperties2;
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties_ = {} ) VULKAN_HPP_NOEXCEPT
       : properties( properties_ )
     {}
@@ -51374,6 +55925,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceProperties2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceProperties2*>( this );
@@ -51384,6 +55936,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceProperties2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceProperties2 const& ) const = default;
 #else
@@ -51400,16 +55953,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceProperties2;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties = {};
+
   };
   static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceProperties2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceProperties2>
+  {
+    using Type = PhysicalDeviceProperties2;
+  };
+
   struct PhysicalDeviceProtectedMemoryFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProtectedMemoryFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( VULKAN_HPP_NAMESPACE::Bool32 protectedMemory_ = {} ) VULKAN_HPP_NOEXCEPT
       : protectedMemory( protectedMemory_ )
     {}
@@ -51443,6 +56007,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceProtectedMemoryFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>( this );
@@ -51453,6 +56018,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceProtectedMemoryFeatures const& ) const = default;
 #else
@@ -51469,16 +56035,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 protectedMemory = {};
+
   };
   static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceProtectedMemoryFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceProtectedMemoryFeatures>
+  {
+    using Type = PhysicalDeviceProtectedMemoryFeatures;
+  };
+
   struct PhysicalDeviceProtectedMemoryProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProtectedMemoryProperties;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryProperties( VULKAN_HPP_NAMESPACE::Bool32 protectedNoFault_ = {} ) VULKAN_HPP_NOEXCEPT
       : protectedNoFault( protectedNoFault_ )
     {}
@@ -51500,6 +56077,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceProtectedMemoryProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>( this );
@@ -51510,6 +56088,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceProtectedMemoryProperties const& ) const = default;
 #else
@@ -51526,16 +56105,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 protectedNoFault = {};
+
   };
   static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceProtectedMemoryProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceProtectedMemoryProperties>
+  {
+    using Type = PhysicalDeviceProtectedMemoryProperties;
+  };
+
   struct PhysicalDevicePushDescriptorPropertiesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
+
     VULKAN_HPP_CONSTEXPR PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = {} ) VULKAN_HPP_NOEXCEPT
       : maxPushDescriptors( maxPushDescriptors_ )
     {}
@@ -51557,6 +56147,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDevicePushDescriptorPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>( this );
@@ -51567,6 +56158,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDevicePushDescriptorPropertiesKHR const& ) const = default;
 #else
@@ -51583,17 +56175,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
     void* pNext = {};
     uint32_t maxPushDescriptors = {};
+
   };
   static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevicePushDescriptorPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDevicePushDescriptorPropertiesKHR>
+  {
+    using Type = PhysicalDevicePushDescriptorPropertiesKHR;
+  };
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct PhysicalDeviceRayTracingFeaturesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingFeaturesKHR;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 rayTracing_ = {},
                                                               VULKAN_HPP_NAMESPACE::Bool32 rayTracingShaderGroupHandleCaptureReplay_ = {},
                                                               VULKAN_HPP_NAMESPACE::Bool32 rayTracingShaderGroupHandleCaptureReplayMixed_ = {},
@@ -51691,6 +56294,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceRayTracingFeaturesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRayTracingFeaturesKHR*>( this );
@@ -51701,6 +56305,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRayTracingFeaturesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceRayTracingFeaturesKHR const& ) const = default;
 #else
@@ -51725,6 +56330,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRayTracingFeaturesKHR;
     void* pNext = {};
@@ -51737,14 +56344,23 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 rayTracingHostAccelerationStructureCommands = {};
     VULKAN_HPP_NAMESPACE::Bool32 rayQuery = {};
     VULKAN_HPP_NAMESPACE::Bool32 rayTracingPrimitiveCulling = {};
+
   };
   static_assert( sizeof( PhysicalDeviceRayTracingFeaturesKHR ) == sizeof( VkPhysicalDeviceRayTracingFeaturesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceRayTracingFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceRayTracingFeaturesKHR>
+  {
+    using Type = PhysicalDeviceRayTracingFeaturesKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct PhysicalDeviceRayTracingPropertiesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPropertiesKHR;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesKHR( uint32_t shaderGroupHandleSize_ = {},
                                                                 uint32_t maxRecursionDepth_ = {},
                                                                 uint32_t maxShaderGroupStride_ = {},
@@ -51782,6 +56398,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceRayTracingPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesKHR*>( this );
@@ -51792,6 +56409,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceRayTracingPropertiesKHR const& ) const = default;
 #else
@@ -51816,6 +56434,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesKHR;
     void* pNext = {};
@@ -51828,13 +56448,22 @@ namespace VULKAN_HPP_NAMESPACE
     uint64_t maxPrimitiveCount = {};
     uint32_t maxDescriptorSetAccelerationStructures = {};
     uint32_t shaderGroupHandleCaptureReplaySize = {};
+
   };
   static_assert( sizeof( PhysicalDeviceRayTracingPropertiesKHR ) == sizeof( VkPhysicalDeviceRayTracingPropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceRayTracingPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceRayTracingPropertiesKHR>
+  {
+    using Type = PhysicalDeviceRayTracingPropertiesKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct PhysicalDeviceRayTracingPropertiesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPropertiesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = {},
                                                                uint32_t maxRecursionDepth_ = {},
                                                                uint32_t maxShaderGroupStride_ = {},
@@ -51870,6 +56499,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceRayTracingPropertiesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>( this );
@@ -51880,6 +56510,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceRayTracingPropertiesNV const& ) const = default;
 #else
@@ -51903,6 +56534,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV;
     void* pNext = {};
@@ -51914,12 +56547,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint64_t maxInstanceCount = {};
     uint64_t maxTriangleCount = {};
     uint32_t maxDescriptorSetAccelerationStructures = {};
+
   };
   static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceRayTracingPropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceRayTracingPropertiesNV>
+  {
+    using Type = PhysicalDeviceRayTracingPropertiesNV;
+  };
+
   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTest_ = {} ) VULKAN_HPP_NOEXCEPT
       : representativeFragmentTest( representativeFragmentTest_ )
     {}
@@ -51953,6 +56595,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>( this );
@@ -51963,6 +56606,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& ) const = default;
 #else
@@ -51979,16 +56623,203 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTest = {};
+
   };
   static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceRepresentativeFragmentTestFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV>
+  {
+    using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
+  };
+
+  struct PhysicalDeviceRobustness2FeaturesEXT
+  {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2FeaturesEXT;
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ = {},
+                                                               VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_ = {},
+                                                               VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_ = {} ) VULKAN_HPP_NOEXCEPT
+      : robustBufferAccess2( robustBufferAccess2_ )
+      , robustImageAccess2( robustImageAccess2_ )
+      , nullDescriptor( nullDescriptor_ )
+    {}
+
+    PhysicalDeviceRobustness2FeaturesEXT & operator=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceRobustness2FeaturesEXT ) - offsetof( PhysicalDeviceRobustness2FeaturesEXT, pNext ) );
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT( VkPhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT& operator=( VkPhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const *>(&rhs);
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT & setPNext( void* pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT & setRobustBufferAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ ) VULKAN_HPP_NOEXCEPT
+    {
+      robustBufferAccess2 = robustBufferAccess2_;
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT & setRobustImageAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_ ) VULKAN_HPP_NOEXCEPT
+    {
+      robustImageAccess2 = robustImageAccess2_;
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT & setNullDescriptor( VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_ ) VULKAN_HPP_NOEXCEPT
+    {
+      nullDescriptor = nullDescriptor_;
+      return *this;
+    }
+
+
+    operator VkPhysicalDeviceRobustness2FeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceRobustness2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>( this );
+    }
+
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+    auto operator<=>( PhysicalDeviceRobustness2FeaturesEXT const& ) const = default;
+#else
+    bool operator==( PhysicalDeviceRobustness2FeaturesEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( robustBufferAccess2 == rhs.robustBufferAccess2 )
+          && ( robustImageAccess2 == rhs.robustImageAccess2 )
+          && ( nullDescriptor == rhs.nullDescriptor );
+    }
+
+    bool operator!=( PhysicalDeviceRobustness2FeaturesEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2FeaturesEXT;
+    void* pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2 = {};
+    VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2 = {};
+    VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor = {};
+
+  };
+  static_assert( sizeof( PhysicalDeviceRobustness2FeaturesEXT ) == sizeof( VkPhysicalDeviceRobustness2FeaturesEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceRobustness2FeaturesEXT>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceRobustness2FeaturesEXT>
+  {
+    using Type = PhysicalDeviceRobustness2FeaturesEXT;
+  };
+
+  struct PhysicalDeviceRobustness2PropertiesEXT
+  {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2PropertiesEXT;
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesEXT( VULKAN_HPP_NAMESPACE::DeviceSize robustStorageBufferAccessSizeAlignment_ = {},
+                                                                 VULKAN_HPP_NAMESPACE::DeviceSize robustUniformBufferAccessSizeAlignment_ = {} ) VULKAN_HPP_NOEXCEPT
+      : robustStorageBufferAccessSizeAlignment( robustStorageBufferAccessSizeAlignment_ )
+      , robustUniformBufferAccessSizeAlignment( robustUniformBufferAccessSizeAlignment_ )
+    {}
+
+    PhysicalDeviceRobustness2PropertiesEXT & operator=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceRobustness2PropertiesEXT ) - offsetof( PhysicalDeviceRobustness2PropertiesEXT, pNext ) );
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2PropertiesEXT( VkPhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+    PhysicalDeviceRobustness2PropertiesEXT& operator=( VkPhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const *>(&rhs);
+      return *this;
+    }
+
+
+    operator VkPhysicalDeviceRobustness2PropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceRobustness2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>( this );
+    }
+
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+    auto operator<=>( PhysicalDeviceRobustness2PropertiesEXT const& ) const = default;
+#else
+    bool operator==( PhysicalDeviceRobustness2PropertiesEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment )
+          && ( robustUniformBufferAccessSizeAlignment == rhs.robustUniformBufferAccessSizeAlignment );
+    }
+
+    bool operator!=( PhysicalDeviceRobustness2PropertiesEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2PropertiesEXT;
+    void* pNext = {};
+    VULKAN_HPP_NAMESPACE::DeviceSize robustStorageBufferAccessSizeAlignment = {};
+    VULKAN_HPP_NAMESPACE::DeviceSize robustUniformBufferAccessSizeAlignment = {};
+
+  };
+  static_assert( sizeof( PhysicalDeviceRobustness2PropertiesEXT ) == sizeof( VkPhysicalDeviceRobustness2PropertiesEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceRobustness2PropertiesEXT>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceRobustness2PropertiesEXT>
+  {
+    using Type = PhysicalDeviceRobustness2PropertiesEXT;
+  };
+
   struct PhysicalDeviceSampleLocationsPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSampleLocationsPropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlags sampleLocationSampleCounts_ = {},
                                                                         VULKAN_HPP_NAMESPACE::Extent2D maxSampleLocationGridSize_ = {},
                                                                         std::array<float,2> const& sampleLocationCoordinateRange_ = {},
@@ -52018,6 +56849,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceSampleLocationsPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>( this );
@@ -52028,6 +56860,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceSampleLocationsPropertiesEXT const& ) const = default;
 #else
@@ -52048,6 +56881,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT;
     void* pNext = {};
@@ -52056,12 +56891,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> sampleLocationCoordinateRange = {};
     uint32_t sampleLocationSubPixelBits = {};
     VULKAN_HPP_NAMESPACE::Bool32 variableSampleLocations = {};
+
   };
   static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSampleLocationsPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT>
+  {
+    using Type = PhysicalDeviceSampleLocationsPropertiesEXT;
+  };
+
   struct PhysicalDeviceSamplerFilterMinmaxProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerFilterMinmaxProperties( VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxSingleComponentFormats_ = {},
                                                                       VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxImageComponentMapping_ = {} ) VULKAN_HPP_NOEXCEPT
       : filterMinmaxSingleComponentFormats( filterMinmaxSingleComponentFormats_ )
@@ -52085,6 +56929,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceSamplerFilterMinmaxProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>( this );
@@ -52095,6 +56940,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceSamplerFilterMinmaxProperties const& ) const = default;
 #else
@@ -52112,17 +56958,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxSingleComponentFormats = {};
     VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxImageComponentMapping = {};
+
   };
   static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxProperties ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSamplerFilterMinmaxProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties>
+  {
+    using Type = PhysicalDeviceSamplerFilterMinmaxProperties;
+  };
+
   struct PhysicalDeviceSamplerYcbcrConversionFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( VULKAN_HPP_NAMESPACE::Bool32 samplerYcbcrConversion_ = {} ) VULKAN_HPP_NOEXCEPT
       : samplerYcbcrConversion( samplerYcbcrConversion_ )
     {}
@@ -52156,6 +57013,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>( this );
@@ -52166,6 +57024,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceSamplerYcbcrConversionFeatures const& ) const = default;
 #else
@@ -52182,16 +57041,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 samplerYcbcrConversion = {};
+
   };
   static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSamplerYcbcrConversionFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures>
+  {
+    using Type = PhysicalDeviceSamplerYcbcrConversionFeatures;
+  };
+
   struct PhysicalDeviceScalarBlockLayoutFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceScalarBlockLayoutFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeatures( VULKAN_HPP_NAMESPACE::Bool32 scalarBlockLayout_ = {} ) VULKAN_HPP_NOEXCEPT
       : scalarBlockLayout( scalarBlockLayout_ )
     {}
@@ -52225,6 +57095,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceScalarBlockLayoutFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>( this );
@@ -52235,6 +57106,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceScalarBlockLayoutFeatures const& ) const = default;
 #else
@@ -52251,16 +57123,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 scalarBlockLayout = {};
+
   };
   static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeatures ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceScalarBlockLayoutFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceScalarBlockLayoutFeatures>
+  {
+    using Type = PhysicalDeviceScalarBlockLayoutFeatures;
+  };
+
   struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSeparateDepthStencilLayoutsFeatures( VULKAN_HPP_NAMESPACE::Bool32 separateDepthStencilLayouts_ = {} ) VULKAN_HPP_NOEXCEPT
       : separateDepthStencilLayouts( separateDepthStencilLayouts_ )
     {}
@@ -52294,6 +57177,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>( this );
@@ -52304,6 +57188,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const& ) const = default;
 #else
@@ -52320,16 +57205,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 separateDepthStencilLayouts = {};
+
   };
   static_assert( sizeof( PhysicalDeviceSeparateDepthStencilLayoutsFeatures ) == sizeof( VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSeparateDepthStencilLayoutsFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures>
+  {
+    using Type = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
+  };
+
   struct PhysicalDeviceShaderAtomicInt64Features
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAtomicInt64Features;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64Features( VULKAN_HPP_NAMESPACE::Bool32 shaderBufferInt64Atomics_ = {},
                                                                   VULKAN_HPP_NAMESPACE::Bool32 shaderSharedInt64Atomics_ = {} ) VULKAN_HPP_NOEXCEPT
       : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ )
@@ -52371,6 +57267,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderAtomicInt64Features const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>( this );
@@ -52381,6 +57278,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderAtomicInt64Features const& ) const = default;
 #else
@@ -52398,17 +57296,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64Features;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderBufferInt64Atomics = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderSharedInt64Atomics = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderAtomicInt64Features ) == sizeof( VkPhysicalDeviceShaderAtomicInt64Features ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderAtomicInt64Features>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderAtomicInt64Features>
+  {
+    using Type = PhysicalDeviceShaderAtomicInt64Features;
+  };
+
   struct PhysicalDeviceShaderClockFeaturesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupClock_ = {},
                                                                VULKAN_HPP_NAMESPACE::Bool32 shaderDeviceClock_ = {} ) VULKAN_HPP_NOEXCEPT
       : shaderSubgroupClock( shaderSubgroupClock_ )
@@ -52450,6 +57359,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderClockFeaturesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>( this );
@@ -52460,6 +57370,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderClockFeaturesKHR const& ) const = default;
 #else
@@ -52477,17 +57388,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupClock = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderDeviceClock = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderClockFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderClockFeaturesKHR>
+  {
+    using Type = PhysicalDeviceShaderClockFeaturesKHR;
+  };
+
   struct PhysicalDeviceShaderCoreProperties2AMD
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreProperties2AMD( VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD shaderCoreFeatures_ = {},
                                                                  uint32_t activeComputeUnitCount_ = {} ) VULKAN_HPP_NOEXCEPT
       : shaderCoreFeatures( shaderCoreFeatures_ )
@@ -52511,6 +57433,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderCoreProperties2AMD const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>( this );
@@ -52521,6 +57444,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderCoreProperties2AMD const& ) const = default;
 #else
@@ -52538,17 +57462,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD shaderCoreFeatures = {};
     uint32_t activeComputeUnitCount = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderCoreProperties2AMD>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderCoreProperties2AMD>
+  {
+    using Type = PhysicalDeviceShaderCoreProperties2AMD;
+  };
+
   struct PhysicalDeviceShaderCorePropertiesAMD
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesAMD( uint32_t shaderEngineCount_ = {},
                                                                 uint32_t shaderArraysPerEngineCount_ = {},
                                                                 uint32_t computeUnitsPerShaderArray_ = {},
@@ -52596,6 +57531,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderCorePropertiesAMD const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>( this );
@@ -52606,6 +57542,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderCorePropertiesAMD const& ) const = default;
 #else
@@ -52635,6 +57572,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD;
     void* pNext = {};
@@ -52652,12 +57591,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t minVgprAllocation = {};
     uint32_t maxVgprAllocation = {};
     uint32_t vgprAllocationGranularity = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderCorePropertiesAMD>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderCorePropertiesAMD>
+  {
+    using Type = PhysicalDeviceShaderCorePropertiesAMD;
+  };
+
   struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 shaderDemoteToHelperInvocation_ = {} ) VULKAN_HPP_NOEXCEPT
       : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ )
     {}
@@ -52691,6 +57639,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>( this );
@@ -52701,6 +57650,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const& ) const = default;
 #else
@@ -52717,16 +57667,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderDemoteToHelperInvocation = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>
+  {
+    using Type = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
+  };
+
   struct PhysicalDeviceShaderDrawParametersFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( VULKAN_HPP_NAMESPACE::Bool32 shaderDrawParameters_ = {} ) VULKAN_HPP_NOEXCEPT
       : shaderDrawParameters( shaderDrawParameters_ )
     {}
@@ -52760,6 +57721,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderDrawParametersFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>( this );
@@ -52770,6 +57732,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderDrawParametersFeatures const& ) const = default;
 #else
@@ -52786,16 +57749,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderDrawParameters = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderDrawParametersFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderDrawParametersFeatures>
+  {
+    using Type = PhysicalDeviceShaderDrawParametersFeatures;
+  };
+
   struct PhysicalDeviceShaderFloat16Int8Features
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFloat16Int8Features;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8Features( VULKAN_HPP_NAMESPACE::Bool32 shaderFloat16_ = {},
                                                                   VULKAN_HPP_NAMESPACE::Bool32 shaderInt8_ = {} ) VULKAN_HPP_NOEXCEPT
       : shaderFloat16( shaderFloat16_ )
@@ -52837,6 +57811,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderFloat16Int8Features const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>( this );
@@ -52847,6 +57822,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderFloat16Int8Features const& ) const = default;
 #else
@@ -52864,17 +57840,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8Features;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderFloat16 = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderInt8 = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderFloat16Int8Features ) == sizeof( VkPhysicalDeviceShaderFloat16Int8Features ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderFloat16Int8Features>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderFloat16Int8Features>
+  {
+    using Type = PhysicalDeviceShaderFloat16Int8Features;
+  };
+
   struct PhysicalDeviceShaderImageFootprintFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 imageFootprint_ = {} ) VULKAN_HPP_NOEXCEPT
       : imageFootprint( imageFootprint_ )
     {}
@@ -52908,6 +57895,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>( this );
@@ -52918,6 +57906,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderImageFootprintFeaturesNV const& ) const = default;
 #else
@@ -52934,16 +57923,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 imageFootprint = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderImageFootprintFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV>
+  {
+    using Type = PhysicalDeviceShaderImageFootprintFeaturesNV;
+  };
+
   struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VULKAN_HPP_NAMESPACE::Bool32 shaderIntegerFunctions2_ = {} ) VULKAN_HPP_NOEXCEPT
       : shaderIntegerFunctions2( shaderIntegerFunctions2_ )
     {}
@@ -52977,6 +57977,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>( this );
@@ -52987,6 +57988,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const& ) const = default;
 #else
@@ -53003,16 +58005,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderIntegerFunctions2 = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>
+  {
+    using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
+  };
+
   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 shaderSMBuiltins_ = {} ) VULKAN_HPP_NOEXCEPT
       : shaderSMBuiltins( shaderSMBuiltins_ )
     {}
@@ -53046,6 +58059,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>( this );
@@ -53056,6 +58070,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderSMBuiltinsFeaturesNV const& ) const = default;
 #else
@@ -53072,16 +58087,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderSMBuiltins = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderSMBuiltinsFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV>
+  {
+    using Type = PhysicalDeviceShaderSMBuiltinsFeaturesNV;
+  };
+
   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsPropertiesNV( uint32_t shaderSMCount_ = {},
                                                                      uint32_t shaderWarpsPerSM_ = {} ) VULKAN_HPP_NOEXCEPT
       : shaderSMCount( shaderSMCount_ )
@@ -53105,6 +58131,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>( this );
@@ -53115,6 +58142,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderSMBuiltinsPropertiesNV const& ) const = default;
 #else
@@ -53132,17 +58160,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV;
     void* pNext = {};
     uint32_t shaderSMCount = {};
     uint32_t shaderWarpsPerSM = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderSMBuiltinsPropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV>
+  {
+    using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV;
+  };
+
   struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeatures( VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupExtendedTypes_ = {} ) VULKAN_HPP_NOEXCEPT
       : shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ )
     {}
@@ -53176,6 +58215,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>( this );
@@ -53186,6 +58226,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const& ) const = default;
 #else
@@ -53202,16 +58243,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupExtendedTypes = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeatures ) == sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderSubgroupExtendedTypesFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures>
+  {
+    using Type = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
+  };
+
   struct PhysicalDeviceShadingRateImageFeaturesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImage_ = {},
                                                                    VULKAN_HPP_NAMESPACE::Bool32 shadingRateCoarseSampleOrder_ = {} ) VULKAN_HPP_NOEXCEPT
       : shadingRateImage( shadingRateImage_ )
@@ -53253,6 +58305,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShadingRateImageFeaturesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>( this );
@@ -53263,6 +58316,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShadingRateImageFeaturesNV const& ) const = default;
 #else
@@ -53280,17 +58334,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 shadingRateImage = {};
     VULKAN_HPP_NAMESPACE::Bool32 shadingRateCoarseSampleOrder = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShadingRateImageFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShadingRateImageFeaturesNV>
+  {
+    using Type = PhysicalDeviceShadingRateImageFeaturesNV;
+  };
+
   struct PhysicalDeviceShadingRateImagePropertiesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImagePropertiesNV( VULKAN_HPP_NAMESPACE::Extent2D shadingRateTexelSize_ = {},
                                                                      uint32_t shadingRatePaletteSize_ = {},
                                                                      uint32_t shadingRateMaxCoarseSamples_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -53316,6 +58381,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceShadingRateImagePropertiesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>( this );
@@ -53326,6 +58392,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceShadingRateImagePropertiesNV const& ) const = default;
 #else
@@ -53344,18 +58411,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Extent2D shadingRateTexelSize = {};
     uint32_t shadingRatePaletteSize = {};
     uint32_t shadingRateMaxCoarseSamples = {};
+
   };
   static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShadingRateImagePropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShadingRateImagePropertiesNV>
+  {
+    using Type = PhysicalDeviceShadingRateImagePropertiesNV;
+  };
+
   struct PhysicalDeviceSparseImageFormatInfo2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSparseImageFormatInfo2;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
                                                                VULKAN_HPP_NAMESPACE::ImageType type_ = VULKAN_HPP_NAMESPACE::ImageType::e1D,
                                                                VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1,
@@ -53421,6 +58499,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceSparseImageFormatInfo2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( this );
@@ -53431,6 +58510,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceSparseImageFormatInfo2 const& ) const = default;
 #else
@@ -53451,6 +58531,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2;
     const void* pNext = {};
@@ -53459,12 +58541,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1;
     VULKAN_HPP_NAMESPACE::ImageUsageFlags usage = {};
     VULKAN_HPP_NAMESPACE::ImageTiling tiling = VULKAN_HPP_NAMESPACE::ImageTiling::eOptimal;
+
   };
   static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSparseImageFormatInfo2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceSparseImageFormatInfo2>
+  {
+    using Type = PhysicalDeviceSparseImageFormatInfo2;
+  };
+
   struct PhysicalDeviceSubgroupProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupProperties;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupProperties( uint32_t subgroupSize_ = {},
                                                            VULKAN_HPP_NAMESPACE::ShaderStageFlags supportedStages_ = {},
                                                            VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags supportedOperations_ = {},
@@ -53492,6 +58583,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceSubgroupProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>( this );
@@ -53502,6 +58594,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceSubgroupProperties const& ) const = default;
 #else
@@ -53521,6 +58614,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties;
     void* pNext = {};
@@ -53528,12 +58623,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ShaderStageFlags supportedStages = {};
     VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags supportedOperations = {};
     VULKAN_HPP_NAMESPACE::Bool32 quadOperationsInAllStages = {};
+
   };
   static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSubgroupProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceSubgroupProperties>
+  {
+    using Type = PhysicalDeviceSubgroupProperties;
+  };
+
   struct PhysicalDeviceSubgroupSizeControlFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 subgroupSizeControl_ = {},
                                                                        VULKAN_HPP_NAMESPACE::Bool32 computeFullSubgroups_ = {} ) VULKAN_HPP_NOEXCEPT
       : subgroupSizeControl( subgroupSizeControl_ )
@@ -53575,6 +58679,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>( this );
@@ -53585,6 +58690,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceSubgroupSizeControlFeaturesEXT const& ) const = default;
 #else
@@ -53602,17 +58708,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 subgroupSizeControl = {};
     VULKAN_HPP_NAMESPACE::Bool32 computeFullSubgroups = {};
+
   };
   static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSubgroupSizeControlFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT>
+  {
+    using Type = PhysicalDeviceSubgroupSizeControlFeaturesEXT;
+  };
+
   struct PhysicalDeviceSubgroupSizeControlPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlPropertiesEXT( uint32_t minSubgroupSize_ = {},
                                                                          uint32_t maxSubgroupSize_ = {},
                                                                          uint32_t maxComputeWorkgroupSubgroups_ = {},
@@ -53640,6 +58757,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>( this );
@@ -53650,6 +58768,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceSubgroupSizeControlPropertiesEXT const& ) const = default;
 #else
@@ -53669,6 +58788,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT;
     void* pNext = {};
@@ -53676,12 +58797,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t maxSubgroupSize = {};
     uint32_t maxComputeWorkgroupSubgroups = {};
     VULKAN_HPP_NAMESPACE::ShaderStageFlags requiredSubgroupSizeStages = {};
+
   };
   static_assert( sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSubgroupSizeControlPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT>
+  {
+    using Type = PhysicalDeviceSubgroupSizeControlPropertiesEXT;
+  };
+
   struct PhysicalDeviceSurfaceInfo2KHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface_ = {} ) VULKAN_HPP_NOEXCEPT
       : surface( surface_ )
     {}
@@ -53715,6 +58845,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceSurfaceInfo2KHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( this );
@@ -53725,6 +58856,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceSurfaceInfo2KHR const& ) const = default;
 #else
@@ -53741,16 +58873,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::SurfaceKHR surface = {};
+
   };
   static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSurfaceInfo2KHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceSurfaceInfo2KHR>
+  {
+    using Type = PhysicalDeviceSurfaceInfo2KHR;
+  };
+
   struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 texelBufferAlignment_ = {} ) VULKAN_HPP_NOEXCEPT
       : texelBufferAlignment( texelBufferAlignment_ )
     {}
@@ -53784,6 +58927,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>( this );
@@ -53794,6 +58938,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const& ) const = default;
 #else
@@ -53810,16 +58955,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 texelBufferAlignment = {};
+
   };
   static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTexelBufferAlignmentFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT>
+  {
+    using Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
+  };
+
   struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VULKAN_HPP_NAMESPACE::DeviceSize storageTexelBufferOffsetAlignmentBytes_ = {},
                                                                           VULKAN_HPP_NAMESPACE::Bool32 storageTexelBufferOffsetSingleTexelAlignment_ = {},
                                                                           VULKAN_HPP_NAMESPACE::DeviceSize uniformTexelBufferOffsetAlignmentBytes_ = {},
@@ -53847,6 +59003,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>( this );
@@ -53857,6 +59014,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const& ) const = default;
 #else
@@ -53876,6 +59034,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT;
     void* pNext = {};
@@ -53883,12 +59043,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 storageTexelBufferOffsetSingleTexelAlignment = {};
     VULKAN_HPP_NAMESPACE::DeviceSize uniformTexelBufferOffsetAlignmentBytes = {};
     VULKAN_HPP_NAMESPACE::Bool32 uniformTexelBufferOffsetSingleTexelAlignment = {};
+
   };
   static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTexelBufferAlignmentPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT>
+  {
+    using Type = PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
+  };
+
   struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 textureCompressionASTC_HDR_ = {} ) VULKAN_HPP_NOEXCEPT
       : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ )
     {}
@@ -53922,6 +59091,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>( this );
@@ -53932,6 +59102,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const& ) const = default;
 #else
@@ -53948,16 +59119,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 textureCompressionASTC_HDR = {};
+
   };
   static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT>
+  {
+    using Type = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
+  };
+
   struct PhysicalDeviceTimelineSemaphoreFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTimelineSemaphoreFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeatures( VULKAN_HPP_NAMESPACE::Bool32 timelineSemaphore_ = {} ) VULKAN_HPP_NOEXCEPT
       : timelineSemaphore( timelineSemaphore_ )
     {}
@@ -53991,6 +59173,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceTimelineSemaphoreFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>( this );
@@ -54001,6 +59184,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceTimelineSemaphoreFeatures const& ) const = default;
 #else
@@ -54017,16 +59201,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 timelineSemaphore = {};
+
   };
   static_assert( sizeof( PhysicalDeviceTimelineSemaphoreFeatures ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTimelineSemaphoreFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceTimelineSemaphoreFeatures>
+  {
+    using Type = PhysicalDeviceTimelineSemaphoreFeatures;
+  };
+
   struct PhysicalDeviceTimelineSemaphoreProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTimelineSemaphoreProperties;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreProperties( uint64_t maxTimelineSemaphoreValueDifference_ = {} ) VULKAN_HPP_NOEXCEPT
       : maxTimelineSemaphoreValueDifference( maxTimelineSemaphoreValueDifference_ )
     {}
@@ -54048,6 +59243,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceTimelineSemaphoreProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>( this );
@@ -54058,6 +59254,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceTimelineSemaphoreProperties const& ) const = default;
 #else
@@ -54074,16 +59271,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreProperties;
     void* pNext = {};
     uint64_t maxTimelineSemaphoreValueDifference = {};
+
   };
   static_assert( sizeof( PhysicalDeviceTimelineSemaphoreProperties ) == sizeof( VkPhysicalDeviceTimelineSemaphoreProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTimelineSemaphoreProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceTimelineSemaphoreProperties>
+  {
+    using Type = PhysicalDeviceTimelineSemaphoreProperties;
+  };
+
   struct PhysicalDeviceToolPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceToolPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceToolPropertiesEXT( std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& name_ = {},
                                                              std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& version_ = {},
                                                              VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT purposes_ = {},
@@ -54113,6 +59321,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceToolPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceToolPropertiesEXT*>( this );
@@ -54123,6 +59332,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceToolPropertiesEXT const& ) const = default;
 #else
@@ -54143,6 +59353,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceToolPropertiesEXT;
     void* pNext = {};
@@ -54151,12 +59363,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT purposes = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> layer = {};
+
   };
   static_assert( sizeof( PhysicalDeviceToolPropertiesEXT ) == sizeof( VkPhysicalDeviceToolPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceToolPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceToolPropertiesEXT>
+  {
+    using Type = PhysicalDeviceToolPropertiesEXT;
+  };
+
   struct PhysicalDeviceTransformFeedbackFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 transformFeedback_ = {},
                                                                      VULKAN_HPP_NAMESPACE::Bool32 geometryStreams_ = {} ) VULKAN_HPP_NOEXCEPT
       : transformFeedback( transformFeedback_ )
@@ -54198,6 +59419,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>( this );
@@ -54208,6 +59430,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceTransformFeedbackFeaturesEXT const& ) const = default;
 #else
@@ -54225,17 +59448,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 transformFeedback = {};
     VULKAN_HPP_NAMESPACE::Bool32 geometryStreams = {};
+
   };
   static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTransformFeedbackFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT>
+  {
+    using Type = PhysicalDeviceTransformFeedbackFeaturesEXT;
+  };
+
   struct PhysicalDeviceTransformFeedbackPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackPropertiesEXT( uint32_t maxTransformFeedbackStreams_ = {},
                                                                        uint32_t maxTransformFeedbackBuffers_ = {},
                                                                        VULKAN_HPP_NAMESPACE::DeviceSize maxTransformFeedbackBufferSize_ = {},
@@ -54275,6 +59509,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>( this );
@@ -54285,6 +59520,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceTransformFeedbackPropertiesEXT const& ) const = default;
 #else
@@ -54310,6 +59546,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT;
     void* pNext = {};
@@ -54323,12 +59561,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 transformFeedbackStreamsLinesTriangles = {};
     VULKAN_HPP_NAMESPACE::Bool32 transformFeedbackRasterizationStreamSelect = {};
     VULKAN_HPP_NAMESPACE::Bool32 transformFeedbackDraw = {};
+
   };
   static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTransformFeedbackPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT>
+  {
+    using Type = PhysicalDeviceTransformFeedbackPropertiesEXT;
+  };
+
   struct PhysicalDeviceUniformBufferStandardLayoutFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeatures( VULKAN_HPP_NAMESPACE::Bool32 uniformBufferStandardLayout_ = {} ) VULKAN_HPP_NOEXCEPT
       : uniformBufferStandardLayout( uniformBufferStandardLayout_ )
     {}
@@ -54362,6 +59609,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>( this );
@@ -54372,6 +59620,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceUniformBufferStandardLayoutFeatures const& ) const = default;
 #else
@@ -54388,16 +59637,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 uniformBufferStandardLayout = {};
+
   };
   static_assert( sizeof( PhysicalDeviceUniformBufferStandardLayoutFeatures ) == sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceUniformBufferStandardLayoutFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures>
+  {
+    using Type = PhysicalDeviceUniformBufferStandardLayoutFeatures;
+  };
+
   struct PhysicalDeviceVariablePointersFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVariablePointersFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( VULKAN_HPP_NAMESPACE::Bool32 variablePointersStorageBuffer_ = {},
                                                                  VULKAN_HPP_NAMESPACE::Bool32 variablePointers_ = {} ) VULKAN_HPP_NOEXCEPT
       : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
@@ -54439,6 +59699,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceVariablePointersFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>( this );
@@ -54449,6 +59710,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceVariablePointersFeatures const& ) const = default;
 #else
@@ -54466,17 +59728,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 variablePointersStorageBuffer = {};
     VULKAN_HPP_NAMESPACE::Bool32 variablePointers = {};
+
   };
   static_assert( sizeof( PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceVariablePointersFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceVariablePointersFeatures>
+  {
+    using Type = PhysicalDeviceVariablePointersFeatures;
+  };
+
   struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 vertexAttributeInstanceRateDivisor_ = {},
                                                                           VULKAN_HPP_NAMESPACE::Bool32 vertexAttributeInstanceRateZeroDivisor_ = {} ) VULKAN_HPP_NOEXCEPT
       : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ )
@@ -54518,6 +59791,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>( this );
@@ -54528,6 +59802,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& ) const = default;
 #else
@@ -54545,17 +59820,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 vertexAttributeInstanceRateDivisor = {};
     VULKAN_HPP_NAMESPACE::Bool32 vertexAttributeInstanceRateZeroDivisor = {};
+
   };
   static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceVertexAttributeDivisorFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT>
+  {
+    using Type = PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
+  };
+
   struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = {} ) VULKAN_HPP_NOEXCEPT
       : maxVertexAttribDivisor( maxVertexAttribDivisor_ )
     {}
@@ -54577,6 +59863,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>( this );
@@ -54587,6 +59874,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& ) const = default;
 #else
@@ -54603,16 +59891,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT;
     void* pNext = {};
     uint32_t maxVertexAttribDivisor = {};
+
   };
   static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceVertexAttributeDivisorPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT>
+  {
+    using Type = PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
+  };
+
   struct PhysicalDeviceVulkan11Features
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan11Features;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan11Features( VULKAN_HPP_NAMESPACE::Bool32 storageBuffer16BitAccess_ = {},
                                                          VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer16BitAccess_ = {},
                                                          VULKAN_HPP_NAMESPACE::Bool32 storagePushConstant16_ = {},
@@ -54734,6 +60033,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceVulkan11Features const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>( this );
@@ -54744,6 +60044,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVulkan11Features*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceVulkan11Features const& ) const = default;
 #else
@@ -54771,6 +60072,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkan11Features;
     void* pNext = {};
@@ -54786,12 +60089,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 protectedMemory = {};
     VULKAN_HPP_NAMESPACE::Bool32 samplerYcbcrConversion = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderDrawParameters = {};
+
   };
   static_assert( sizeof( PhysicalDeviceVulkan11Features ) == sizeof( VkPhysicalDeviceVulkan11Features ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceVulkan11Features>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceVulkan11Features>
+  {
+    using Type = PhysicalDeviceVulkan11Features;
+  };
+
   struct PhysicalDeviceVulkan11Properties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan11Properties;
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Properties( std::array<uint8_t,VK_UUID_SIZE> const& deviceUUID_ = {},
                                                               std::array<uint8_t,VK_UUID_SIZE> const& driverUUID_ = {},
                                                               std::array<uint8_t,VK_LUID_SIZE> const& deviceLUID_ = {},
@@ -54841,6 +60153,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceVulkan11Properties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>( this );
@@ -54851,6 +60164,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceVulkan11Properties const& ) const = default;
 #else
@@ -54881,6 +60195,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkan11Properties;
     void* pNext = {};
@@ -54899,12 +60215,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 protectedNoFault = {};
     uint32_t maxPerSetDescriptors = {};
     VULKAN_HPP_NAMESPACE::DeviceSize maxMemoryAllocationSize = {};
+
   };
   static_assert( sizeof( PhysicalDeviceVulkan11Properties ) == sizeof( VkPhysicalDeviceVulkan11Properties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceVulkan11Properties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceVulkan11Properties>
+  {
+    using Type = PhysicalDeviceVulkan11Properties;
+  };
+
   struct PhysicalDeviceVulkan12Features
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan12Features;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan12Features( VULKAN_HPP_NAMESPACE::Bool32 samplerMirrorClampToEdge_ = {},
                                                          VULKAN_HPP_NAMESPACE::Bool32 drawIndirectCount_ = {},
                                                          VULKAN_HPP_NAMESPACE::Bool32 storageBuffer8BitAccess_ = {},
@@ -55306,6 +60631,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceVulkan12Features const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>( this );
@@ -55316,6 +60642,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVulkan12Features*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceVulkan12Features const& ) const = default;
 #else
@@ -55378,6 +60705,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkan12Features;
     void* pNext = {};
@@ -55428,12 +60757,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 shaderOutputViewportIndex = {};
     VULKAN_HPP_NAMESPACE::Bool32 shaderOutputLayer = {};
     VULKAN_HPP_NAMESPACE::Bool32 subgroupBroadcastDynamicId = {};
+
   };
   static_assert( sizeof( PhysicalDeviceVulkan12Features ) == sizeof( VkPhysicalDeviceVulkan12Features ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceVulkan12Features>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceVulkan12Features>
+  {
+    using Type = PhysicalDeviceVulkan12Features;
+  };
+
   struct PhysicalDeviceVulkan12Properties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan12Properties;
+
     VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Properties( VULKAN_HPP_NAMESPACE::DriverId driverID_ = VULKAN_HPP_NAMESPACE::DriverId::eAmdProprietary,
                                                               std::array<char,VK_MAX_DRIVER_NAME_SIZE> const& driverName_ = {},
                                                               std::array<char,VK_MAX_DRIVER_INFO_SIZE> const& driverInfo_ = {},
@@ -55557,6 +60895,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceVulkan12Properties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>( this );
@@ -55567,6 +60906,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceVulkan12Properties const& ) const = default;
 #else
@@ -55634,6 +60974,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkan12Properties;
     void* pNext = {};
@@ -55689,12 +61031,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxImageComponentMapping = {};
     uint64_t maxTimelineSemaphoreValueDifference = {};
     VULKAN_HPP_NAMESPACE::SampleCountFlags framebufferIntegerColorSampleCounts = {};
+
   };
   static_assert( sizeof( PhysicalDeviceVulkan12Properties ) == sizeof( VkPhysicalDeviceVulkan12Properties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceVulkan12Properties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceVulkan12Properties>
+  {
+    using Type = PhysicalDeviceVulkan12Properties;
+  };
+
   struct PhysicalDeviceVulkanMemoryModelFeatures
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkanMemoryModelFeatures;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeatures( VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModel_ = {},
                                                                   VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModelDeviceScope_ = {},
                                                                   VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -55744,6 +61095,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceVulkanMemoryModelFeatures const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>( this );
@@ -55754,6 +61106,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceVulkanMemoryModelFeatures const& ) const = default;
 #else
@@ -55772,18 +61125,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeatures;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModel = {};
     VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModelDeviceScope = {};
     VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModelAvailabilityVisibilityChains = {};
+
   };
   static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeatures ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceVulkanMemoryModelFeatures>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceVulkanMemoryModelFeatures>
+  {
+    using Type = PhysicalDeviceVulkanMemoryModelFeatures;
+  };
+
   struct PhysicalDeviceYcbcrImageArraysFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 ycbcrImageArrays_ = {} ) VULKAN_HPP_NOEXCEPT
       : ycbcrImageArrays( ycbcrImageArrays_ )
     {}
@@ -55817,6 +61181,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>( this );
@@ -55827,6 +61192,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PhysicalDeviceYcbcrImageArraysFeaturesEXT const& ) const = default;
 #else
@@ -55843,16 +61209,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 ycbcrImageArrays = {};
+
   };
   static_assert( sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceYcbcrImageArraysFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT>
+  {
+    using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT;
+  };
+
   struct PipelineCacheCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCacheCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags flags_ = {},
                                                   size_t initialDataSize_ = {},
                                                   const void* pInitialData_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -55902,6 +61279,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineCacheCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCacheCreateInfo*>( this );
@@ -55912,6 +61290,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCacheCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineCacheCreateInfo const& ) const = default;
 #else
@@ -55930,18 +61309,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCacheCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags flags = {};
     size_t initialDataSize = {};
     const void* pInitialData = {};
+
   };
   static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCacheCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineCacheCreateInfo>
+  {
+    using Type = PipelineCacheCreateInfo;
+  };
+
   struct PipelineColorBlendAdvancedStateCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 srcPremultiplied_ = {},
                                                                        VULKAN_HPP_NAMESPACE::Bool32 dstPremultiplied_ = {},
                                                                        VULKAN_HPP_NAMESPACE::BlendOverlapEXT blendOverlap_ = VULKAN_HPP_NAMESPACE::BlendOverlapEXT::eUncorrelated ) VULKAN_HPP_NOEXCEPT
@@ -55991,6 +61381,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>( this );
@@ -56001,6 +61392,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineColorBlendAdvancedStateCreateInfoEXT const& ) const = default;
 #else
@@ -56019,18 +61411,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 srcPremultiplied = {};
     VULKAN_HPP_NAMESPACE::Bool32 dstPremultiplied = {};
     VULKAN_HPP_NAMESPACE::BlendOverlapEXT blendOverlap = VULKAN_HPP_NAMESPACE::BlendOverlapEXT::eUncorrelated;
+
   };
   static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineColorBlendAdvancedStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT>
+  {
+    using Type = PipelineColorBlendAdvancedStateCreateInfoEXT;
+  };
+
   struct PipelineCompilerControlCreateInfoAMD
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCompilerControlCreateInfoAMD;
+
     VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD compilerControlFlags_ = {} ) VULKAN_HPP_NOEXCEPT
       : compilerControlFlags( compilerControlFlags_ )
     {}
@@ -56064,6 +61467,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineCompilerControlCreateInfoAMD const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>( this );
@@ -56074,6 +61478,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineCompilerControlCreateInfoAMD const& ) const = default;
 #else
@@ -56090,16 +61495,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD compilerControlFlags = {};
+
   };
   static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCompilerControlCreateInfoAMD>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineCompilerControlCreateInfoAMD>
+  {
+    using Type = PipelineCompilerControlCreateInfoAMD;
+  };
+
   struct PipelineCoverageModulationStateCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV flags_ = {},
                                                                       VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode_ = VULKAN_HPP_NAMESPACE::CoverageModulationModeNV::eNone,
                                                                       VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable_ = {},
@@ -56165,6 +61581,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineCoverageModulationStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>( this );
@@ -56175,6 +61592,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineCoverageModulationStateCreateInfoNV const& ) const = default;
 #else
@@ -56195,6 +61613,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
     const void* pNext = {};
@@ -56203,12 +61623,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable = {};
     uint32_t coverageModulationTableCount = {};
     const float* pCoverageModulationTable = {};
+
   };
   static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCoverageModulationStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineCoverageModulationStateCreateInfoNV>
+  {
+    using Type = PipelineCoverageModulationStateCreateInfoNV;
+  };
+
   struct PipelineCoverageReductionStateCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageReductionStateCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV flags_ = {},
                                                                      VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode_ = VULKAN_HPP_NAMESPACE::CoverageReductionModeNV::eMerge ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -56250,6 +61679,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineCoverageReductionStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>( this );
@@ -56260,6 +61690,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineCoverageReductionStateCreateInfoNV const& ) const = default;
 #else
@@ -56277,17 +61708,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV flags = {};
     VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode = VULKAN_HPP_NAMESPACE::CoverageReductionModeNV::eMerge;
+
   };
   static_assert( sizeof( PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCoverageReductionStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineCoverageReductionStateCreateInfoNV>
+  {
+    using Type = PipelineCoverageReductionStateCreateInfoNV;
+  };
+
   struct PipelineCoverageToColorStateCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV flags_ = {},
                                                                    VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable_ = {},
                                                                    uint32_t coverageToColorLocation_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -56337,6 +61779,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineCoverageToColorStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>( this );
@@ -56347,6 +61790,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineCoverageToColorStateCreateInfoNV const& ) const = default;
 #else
@@ -56365,18 +61809,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV flags = {};
     VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable = {};
     uint32_t coverageToColorLocation = {};
+
   };
   static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCoverageToColorStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineCoverageToColorStateCreateInfoNV>
+  {
+    using Type = PipelineCoverageToColorStateCreateInfoNV;
+  };
+
   struct PipelineCreationFeedbackEXT
   {
+
     VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackEXT( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT flags_ = {},
                                                       uint64_t duration_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -56394,6 +61848,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineCreationFeedbackEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCreationFeedbackEXT*>( this );
@@ -56404,6 +61859,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCreationFeedbackEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineCreationFeedbackEXT const& ) const = default;
 #else
@@ -56419,15 +61875,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT flags = {};
     uint64_t duration = {};
+
   };
   static_assert( sizeof( PipelineCreationFeedbackEXT ) == sizeof( VkPipelineCreationFeedbackEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCreationFeedbackEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineCreationFeedbackCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCreationFeedbackCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = {},
                                                                 uint32_t pipelineStageCreationFeedbackCount_ = {},
                                                                 VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -56477,6 +61938,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineCreationFeedbackCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>( this );
@@ -56487,6 +61949,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineCreationFeedbackCreateInfoEXT const& ) const = default;
 #else
@@ -56505,18 +61968,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT* pPipelineCreationFeedback = {};
     uint32_t pipelineStageCreationFeedbackCount = {};
     VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks = {};
+
   };
   static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCreationFeedbackCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineCreationFeedbackCreateInfoEXT>
+  {
+    using Type = PipelineCreationFeedbackCreateInfoEXT;
+  };
+
   struct PipelineDiscardRectangleStateCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = {},
                                                                      VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode_ = VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT::eInclusive,
                                                                      uint32_t discardRectangleCount_ = {},
@@ -56574,6 +62048,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineDiscardRectangleStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>( this );
@@ -56584,6 +62059,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineDiscardRectangleStateCreateInfoEXT const& ) const = default;
 #else
@@ -56603,6 +62079,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
     const void* pNext = {};
@@ -56610,12 +62088,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode = VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT::eInclusive;
     uint32_t discardRectangleCount = {};
     const VULKAN_HPP_NAMESPACE::Rect2D* pDiscardRectangles = {};
+
   };
   static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineDiscardRectangleStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineDiscardRectangleStateCreateInfoEXT>
+  {
+    using Type = PipelineDiscardRectangleStateCreateInfoEXT;
+  };
+
   struct PipelineExecutableInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableInfoKHR;
+
     VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {},
                                                     uint32_t executableIndex_ = {} ) VULKAN_HPP_NOEXCEPT
       : pipeline( pipeline_ )
@@ -56657,6 +62144,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineExecutableInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineExecutableInfoKHR*>( this );
@@ -56667,6 +62155,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineExecutableInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineExecutableInfoKHR const& ) const = default;
 #else
@@ -56684,17 +62173,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Pipeline pipeline = {};
     uint32_t executableIndex = {};
+
   };
   static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineExecutableInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineExecutableInfoKHR>
+  {
+    using Type = PipelineExecutableInfoKHR;
+  };
+
   struct PipelineExecutableInternalRepresentationKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableInternalRepresentationKHR;
+
     VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = {},
                                                                          std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = {},
                                                                          VULKAN_HPP_NAMESPACE::Bool32 isText_ = {},
@@ -56724,6 +62224,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineExecutableInternalRepresentationKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineExecutableInternalRepresentationKHR*>( this );
@@ -56734,6 +62235,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineExecutableInternalRepresentationKHR const& ) const = default;
 #else
@@ -56754,6 +62256,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR;
     void* pNext = {};
@@ -56762,12 +62266,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 isText = {};
     size_t dataSize = {};
     void* pData = {};
+
   };
   static_assert( sizeof( PipelineExecutableInternalRepresentationKHR ) == sizeof( VkPipelineExecutableInternalRepresentationKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineExecutableInternalRepresentationKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineExecutableInternalRepresentationKHR>
+  {
+    using Type = PipelineExecutableInternalRepresentationKHR;
+  };
+
   struct PipelineExecutablePropertiesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutablePropertiesKHR;
+
     VULKAN_HPP_CONSTEXPR_14 PipelineExecutablePropertiesKHR( VULKAN_HPP_NAMESPACE::ShaderStageFlags stages_ = {},
                                                              std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = {},
                                                              std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = {},
@@ -56795,6 +62308,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineExecutablePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineExecutablePropertiesKHR*>( this );
@@ -56805,6 +62319,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineExecutablePropertiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineExecutablePropertiesKHR const& ) const = default;
 #else
@@ -56824,6 +62339,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutablePropertiesKHR;
     void* pNext = {};
@@ -56831,10 +62348,17 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> name = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {};
     uint32_t subgroupSize = {};
+
   };
   static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineExecutablePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineExecutablePropertiesKHR>
+  {
+    using Type = PipelineExecutablePropertiesKHR;
+  };
+
   union PipelineExecutableStatisticValueKHR
   {
     PipelineExecutableStatisticValueKHR( VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR const& rhs ) VULKAN_HPP_NOEXCEPT
@@ -56843,24 +62367,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     PipelineExecutableStatisticValueKHR( VULKAN_HPP_NAMESPACE::Bool32 b32_ = {} )
-    {
-      b32 = b32_;
-    }
+      : b32( b32_ )
+    {}
 
     PipelineExecutableStatisticValueKHR( int64_t i64_ )
-    {
-      i64 = i64_;
-    }
+      : i64( i64_ )
+    {}
 
     PipelineExecutableStatisticValueKHR( uint64_t u64_ )
-    {
-      u64 = u64_;
-    }
+      : u64( u64_ )
+    {}
 
     PipelineExecutableStatisticValueKHR( double f64_ )
-    {
-      f64 = f64_;
-    }
+      : f64( f64_ )
+    {}
 
     PipelineExecutableStatisticValueKHR & setB32( VULKAN_HPP_NAMESPACE::Bool32 b32_ ) VULKAN_HPP_NOEXCEPT
     {
@@ -56917,6 +62437,8 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PipelineExecutableStatisticKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableStatisticKHR;
+
     PipelineExecutableStatisticKHR( std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = {},
                                     std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = {},
                                     VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR format_ = VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR::eBool32,
@@ -56944,6 +62466,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineExecutableStatisticKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineExecutableStatisticKHR*>( this );
@@ -56954,6 +62477,9 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineExecutableStatisticKHR*>( this );
     }
 
+
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableStatisticKHR;
     void* pNext = {};
@@ -56961,12 +62487,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {};
     VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR format = VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR::eBool32;
     VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR value = {};
+
   };
   static_assert( sizeof( PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineExecutableStatisticKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineExecutableStatisticKHR>
+  {
+    using Type = PipelineExecutableStatisticKHR;
+  };
+
   struct PipelineInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineInfoKHR;
+
     VULKAN_HPP_CONSTEXPR PipelineInfoKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {} ) VULKAN_HPP_NOEXCEPT
       : pipeline( pipeline_ )
     {}
@@ -57000,6 +62535,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineInfoKHR*>( this );
@@ -57010,6 +62546,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineInfoKHR const& ) const = default;
 #else
@@ -57026,16 +62563,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Pipeline pipeline = {};
+
   };
   static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineInfoKHR>
+  {
+    using Type = PipelineInfoKHR;
+  };
+
   struct PushConstantRange
   {
+
     VULKAN_HPP_CONSTEXPR PushConstantRange( VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags_ = {},
                                             uint32_t offset_ = {},
                                             uint32_t size_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -57073,6 +62620,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPushConstantRange const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPushConstantRange*>( this );
@@ -57083,6 +62631,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPushConstantRange*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PushConstantRange const& ) const = default;
 #else
@@ -57099,16 +62648,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags = {};
     uint32_t offset = {};
     uint32_t size = {};
+
   };
   static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PushConstantRange>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineLayoutCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineLayoutCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags flags_ = {},
                                                    uint32_t setLayoutCount_ = {},
                                                    const VULKAN_HPP_NAMESPACE::DescriptorSetLayout* pSetLayouts_ = {},
@@ -57174,6 +62728,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineLayoutCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>( this );
@@ -57184,6 +62739,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineLayoutCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineLayoutCreateInfo const& ) const = default;
 #else
@@ -57204,6 +62760,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineLayoutCreateInfo;
     const void* pNext = {};
@@ -57212,13 +62770,22 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::DescriptorSetLayout* pSetLayouts = {};
     uint32_t pushConstantRangeCount = {};
     const VULKAN_HPP_NAMESPACE::PushConstantRange* pPushConstantRanges = {};
+
   };
   static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineLayoutCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineLayoutCreateInfo>
+  {
+    using Type = PipelineLayoutCreateInfo;
+  };
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct PipelineLibraryCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineLibraryCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR PipelineLibraryCreateInfoKHR( uint32_t libraryCount_ = {},
                                                        const VULKAN_HPP_NAMESPACE::Pipeline* pLibraries_ = {} ) VULKAN_HPP_NOEXCEPT
       : libraryCount( libraryCount_ )
@@ -57260,6 +62827,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineLibraryCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>( this );
@@ -57270,6 +62838,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineLibraryCreateInfoKHR const& ) const = default;
 #else
@@ -57287,18 +62856,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineLibraryCreateInfoKHR;
     const void* pNext = {};
     uint32_t libraryCount = {};
     const VULKAN_HPP_NAMESPACE::Pipeline* pLibraries = {};
+
   };
   static_assert( sizeof( PipelineLibraryCreateInfoKHR ) == sizeof( VkPipelineLibraryCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineLibraryCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineLibraryCreateInfoKHR>
+  {
+    using Type = PipelineLibraryCreateInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct PipelineRasterizationConservativeStateCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = {},
                                                                               VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT::eDisabled,
                                                                               float extraPrimitiveOverestimationSize_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -57348,6 +62928,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineRasterizationConservativeStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>( this );
@@ -57358,6 +62939,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineRasterizationConservativeStateCreateInfoEXT const& ) const = default;
 #else
@@ -57376,18 +62958,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT flags = {};
     VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode = VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT::eDisabled;
     float extraPrimitiveOverestimationSize = {};
+
   };
   static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineRasterizationConservativeStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT>
+  {
+    using Type = PipelineRasterizationConservativeStateCreateInfoEXT;
+  };
+
   struct PipelineRasterizationDepthClipStateCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = {},
                                                                            VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -57429,6 +63022,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>( this );
@@ -57439,6 +63033,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineRasterizationDepthClipStateCreateInfoEXT const& ) const = default;
 #else
@@ -57456,17 +63051,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT flags = {};
     VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable = {};
+
   };
   static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineRasterizationDepthClipStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT>
+  {
+    using Type = PipelineRasterizationDepthClipStateCreateInfoEXT;
+  };
+
   struct PipelineRasterizationLineStateCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationLineStateCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode_ = VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT::eDefault,
                                                                       VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable_ = {},
                                                                       uint32_t lineStippleFactor_ = {},
@@ -57524,6 +63130,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineRasterizationLineStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>( this );
@@ -57534,6 +63141,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineRasterizationLineStateCreateInfoEXT const& ) const = default;
 #else
@@ -57553,6 +63161,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationLineStateCreateInfoEXT;
     const void* pNext = {};
@@ -57560,12 +63170,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable = {};
     uint32_t lineStippleFactor = {};
     uint16_t lineStipplePattern = {};
+
   };
   static_assert( sizeof( PipelineRasterizationLineStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineRasterizationLineStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineRasterizationLineStateCreateInfoEXT>
+  {
+    using Type = PipelineRasterizationLineStateCreateInfoEXT;
+  };
+
   struct PipelineRasterizationStateRasterizationOrderAMD
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
+
     VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( VULKAN_HPP_NAMESPACE::RasterizationOrderAMD rasterizationOrder_ = VULKAN_HPP_NAMESPACE::RasterizationOrderAMD::eStrict ) VULKAN_HPP_NOEXCEPT
       : rasterizationOrder( rasterizationOrder_ )
     {}
@@ -57599,6 +63218,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineRasterizationStateRasterizationOrderAMD const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>( this );
@@ -57609,6 +63229,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineRasterizationStateRasterizationOrderAMD const& ) const = default;
 #else
@@ -57625,16 +63246,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::RasterizationOrderAMD rasterizationOrder = VULKAN_HPP_NAMESPACE::RasterizationOrderAMD::eStrict;
+
   };
   static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineRasterizationStateRasterizationOrderAMD>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineRasterizationStateRasterizationOrderAMD>
+  {
+    using Type = PipelineRasterizationStateRasterizationOrderAMD;
+  };
+
   struct PipelineRasterizationStateStreamCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = {},
                                                                         uint32_t rasterizationStream_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -57676,6 +63308,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineRasterizationStateStreamCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>( this );
@@ -57686,6 +63319,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineRasterizationStateStreamCreateInfoEXT const& ) const = default;
 #else
@@ -57703,17 +63337,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT flags = {};
     uint32_t rasterizationStream = {};
+
   };
   static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineRasterizationStateStreamCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineRasterizationStateStreamCreateInfoEXT>
+  {
+    using Type = PipelineRasterizationStateStreamCreateInfoEXT;
+  };
+
   struct PipelineRepresentativeFragmentTestStateCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable_ = {} ) VULKAN_HPP_NOEXCEPT
       : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
     {}
@@ -57747,6 +63392,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>( this );
@@ -57757,6 +63403,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineRepresentativeFragmentTestStateCreateInfoNV const& ) const = default;
 #else
@@ -57773,16 +63420,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable = {};
+
   };
   static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineRepresentativeFragmentTestStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV>
+  {
+    using Type = PipelineRepresentativeFragmentTestStateCreateInfoNV;
+  };
+
   struct PipelineSampleLocationsStateCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable_ = {},
                                                                     VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT
       : sampleLocationsEnable( sampleLocationsEnable_ )
@@ -57818,12 +63476,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT
+    PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT
     {
       sampleLocationsInfo = sampleLocationsInfo_;
       return *this;
     }
 
+
     operator VkPipelineSampleLocationsStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>( this );
@@ -57834,6 +63493,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineSampleLocationsStateCreateInfoEXT const& ) const = default;
 #else
@@ -57851,17 +63511,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable = {};
     VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo = {};
+
   };
   static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineSampleLocationsStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineSampleLocationsStateCreateInfoEXT>
+  {
+    using Type = PipelineSampleLocationsStateCreateInfoEXT;
+  };
+
   struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( uint32_t requiredSubgroupSize_ = {} ) VULKAN_HPP_NOEXCEPT
       : requiredSubgroupSize( requiredSubgroupSize_ )
     {}
@@ -57883,6 +63554,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>( this );
@@ -57893,6 +63565,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const& ) const = default;
 #else
@@ -57909,16 +63582,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
     void* pNext = {};
     uint32_t requiredSubgroupSize = {};
+
   };
   static_assert( sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) == sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>
+  {
+    using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
+  };
+
   struct PipelineTessellationDomainOriginStateCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo;
+
     VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin_ = VULKAN_HPP_NAMESPACE::TessellationDomainOrigin::eUpperLeft ) VULKAN_HPP_NOEXCEPT
       : domainOrigin( domainOrigin_ )
     {}
@@ -57952,6 +63636,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineTessellationDomainOriginStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>( this );
@@ -57962,6 +63647,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineTessellationDomainOriginStateCreateInfo const& ) const = default;
 #else
@@ -57978,16 +63664,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin = VULKAN_HPP_NAMESPACE::TessellationDomainOrigin::eUpperLeft;
+
   };
   static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineTessellationDomainOriginStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineTessellationDomainOriginStateCreateInfo>
+  {
+    using Type = PipelineTessellationDomainOriginStateCreateInfo;
+  };
+
   struct VertexInputBindingDivisorDescriptionEXT
   {
+
     VULKAN_HPP_CONSTEXPR VertexInputBindingDivisorDescriptionEXT( uint32_t binding_ = {},
                                                                   uint32_t divisor_ = {} ) VULKAN_HPP_NOEXCEPT
       : binding( binding_ )
@@ -58017,6 +63713,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkVertexInputBindingDivisorDescriptionEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVertexInputBindingDivisorDescriptionEXT*>( this );
@@ -58027,6 +63724,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( VertexInputBindingDivisorDescriptionEXT const& ) const = default;
 #else
@@ -58042,15 +63740,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t binding = {};
     uint32_t divisor = {};
+
   };
   static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<VertexInputBindingDivisorDescriptionEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineVertexInputDivisorStateCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = {},
                                                                        const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = {} ) VULKAN_HPP_NOEXCEPT
       : vertexBindingDivisorCount( vertexBindingDivisorCount_ )
@@ -58092,6 +63795,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineVertexInputDivisorStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>( this );
@@ -58102,6 +63806,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineVertexInputDivisorStateCreateInfoEXT const& ) const = default;
 #else
@@ -58119,17 +63824,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT;
     const void* pNext = {};
     uint32_t vertexBindingDivisorCount = {};
     const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors = {};
+
   };
   static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineVertexInputDivisorStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT>
+  {
+    using Type = PipelineVertexInputDivisorStateCreateInfoEXT;
+  };
+
   struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType_ = VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV::eDefault,
                                                                              uint32_t customSampleOrderCount_ = {},
                                                                              const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -58179,6 +63895,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>( this );
@@ -58189,6 +63906,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& ) const = default;
 #else
@@ -58207,18 +63925,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType = VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV::eDefault;
     uint32_t customSampleOrderCount = {};
     const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV* pCustomSampleOrders = {};
+
   };
   static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineViewportCoarseSampleOrderStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV>
+  {
+    using Type = PipelineViewportCoarseSampleOrderStateCreateInfoNV;
+  };
+
   struct PipelineViewportExclusiveScissorStateCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = {},
                                                                             const VULKAN_HPP_NAMESPACE::Rect2D* pExclusiveScissors_ = {} ) VULKAN_HPP_NOEXCEPT
       : exclusiveScissorCount( exclusiveScissorCount_ )
@@ -58260,6 +63989,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>( this );
@@ -58270,6 +64000,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineViewportExclusiveScissorStateCreateInfoNV const& ) const = default;
 #else
@@ -58287,17 +64018,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV;
     const void* pNext = {};
     uint32_t exclusiveScissorCount = {};
     const VULKAN_HPP_NAMESPACE::Rect2D* pExclusiveScissors = {};
+
   };
   static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineViewportExclusiveScissorStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV>
+  {
+    using Type = PipelineViewportExclusiveScissorStateCreateInfoNV;
+  };
+
   struct ShadingRatePaletteNV
   {
+
     VULKAN_HPP_CONSTEXPR ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = {},
                                                const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = {} ) VULKAN_HPP_NOEXCEPT
       : shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ )
@@ -58327,6 +64068,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkShadingRatePaletteNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkShadingRatePaletteNV*>( this );
@@ -58337,6 +64079,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkShadingRatePaletteNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ShadingRatePaletteNV const& ) const = default;
 #else
@@ -58352,15 +64095,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t shadingRatePaletteEntryCount = {};
     const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV* pShadingRatePaletteEntries = {};
+
   };
   static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ShadingRatePaletteNV>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineViewportShadingRateImageStateCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable_ = {},
                                                                             uint32_t viewportCount_ = {},
                                                                             const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV* pShadingRatePalettes_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -58410,6 +64158,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineViewportShadingRateImageStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>( this );
@@ -58420,6 +64169,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineViewportShadingRateImageStateCreateInfoNV const& ) const = default;
 #else
@@ -58438,18 +64188,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable = {};
     uint32_t viewportCount = {};
     const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV* pShadingRatePalettes = {};
+
   };
   static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineViewportShadingRateImageStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV>
+  {
+    using Type = PipelineViewportShadingRateImageStateCreateInfoNV;
+  };
+
   struct ViewportSwizzleNV
   {
+
     VULKAN_HPP_CONSTEXPR ViewportSwizzleNV( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV x_ = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX,
                                             VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV y_ = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX,
                                             VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV z_ = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX,
@@ -58495,6 +64255,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkViewportSwizzleNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkViewportSwizzleNV*>( this );
@@ -58505,6 +64266,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkViewportSwizzleNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ViewportSwizzleNV const& ) const = default;
 #else
@@ -58522,17 +64284,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV x = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX;
     VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV y = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX;
     VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV z = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX;
     VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV w = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX;
+
   };
   static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ViewportSwizzleNV>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineViewportSwizzleStateCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV flags_ = {},
                                                                    uint32_t viewportCount_ = {},
                                                                    const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV* pViewportSwizzles_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -58582,6 +64349,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineViewportSwizzleStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>( this );
@@ -58592,6 +64360,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineViewportSwizzleStateCreateInfoNV const& ) const = default;
 #else
@@ -58610,18 +64379,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV flags = {};
     uint32_t viewportCount = {};
     const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV* pViewportSwizzles = {};
+
   };
   static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineViewportSwizzleStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineViewportSwizzleStateCreateInfoNV>
+  {
+    using Type = PipelineViewportSwizzleStateCreateInfoNV;
+  };
+
   struct ViewportWScalingNV
   {
+
     VULKAN_HPP_CONSTEXPR ViewportWScalingNV( float xcoeff_ = {},
                                              float ycoeff_ = {} ) VULKAN_HPP_NOEXCEPT
       : xcoeff( xcoeff_ )
@@ -58651,6 +64430,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkViewportWScalingNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkViewportWScalingNV*>( this );
@@ -58661,6 +64441,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkViewportWScalingNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ViewportWScalingNV const& ) const = default;
 #else
@@ -58676,15 +64457,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     float xcoeff = {};
     float ycoeff = {};
+
   };
   static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ViewportWScalingNV>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineViewportWScalingStateCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportWScalingStateCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable_ = {},
                                                                     uint32_t viewportCount_ = {},
                                                                     const VULKAN_HPP_NAMESPACE::ViewportWScalingNV* pViewportWScalings_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -58734,6 +64520,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPipelineViewportWScalingStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>( this );
@@ -58744,6 +64531,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PipelineViewportWScalingStateCreateInfoNV const& ) const = default;
 #else
@@ -58762,19 +64550,30 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable = {};
     uint32_t viewportCount = {};
     const VULKAN_HPP_NAMESPACE::ViewportWScalingNV* pViewportWScalings = {};
+
   };
   static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineViewportWScalingStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePipelineViewportWScalingStateCreateInfoNV>
+  {
+    using Type = PipelineViewportWScalingStateCreateInfoNV;
+  };
+
 #ifdef VK_USE_PLATFORM_GGP
   struct PresentFrameTokenGGP
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentFrameTokenGGP;
+
     VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = {} ) VULKAN_HPP_NOEXCEPT
       : frameToken( frameToken_ )
     {}
@@ -58808,6 +64607,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPresentFrameTokenGGP const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentFrameTokenGGP*>( this );
@@ -58818,6 +64618,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentFrameTokenGGP*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PresentFrameTokenGGP const& ) const = default;
 #else
@@ -58834,17 +64635,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePresentFrameTokenGGP;
     const void* pNext = {};
     GgpFrameToken frameToken = {};
+
   };
   static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PresentFrameTokenGGP>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePresentFrameTokenGGP>
+  {
+    using Type = PresentFrameTokenGGP;
+  };
 #endif /*VK_USE_PLATFORM_GGP*/
 
   struct PresentInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentInfoKHR;
+
     VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = {},
                                          const VULKAN_HPP_NAMESPACE::Semaphore* pWaitSemaphores_ = {},
                                          uint32_t swapchainCount_ = {},
@@ -58918,6 +64730,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPresentInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentInfoKHR*>( this );
@@ -58928,6 +64741,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PresentInfoKHR const& ) const = default;
 #else
@@ -58949,6 +64763,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePresentInfoKHR;
     const void* pNext = {};
@@ -58958,12 +64774,20 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::SwapchainKHR* pSwapchains = {};
     const uint32_t* pImageIndices = {};
     VULKAN_HPP_NAMESPACE::Result* pResults = {};
+
   };
   static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PresentInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePresentInfoKHR>
+  {
+    using Type = PresentInfoKHR;
+  };
+
   struct RectLayerKHR
   {
+
     VULKAN_HPP_CONSTEXPR RectLayerKHR( VULKAN_HPP_NAMESPACE::Offset2D offset_ = {},
                                        VULKAN_HPP_NAMESPACE::Extent2D extent_ = {},
                                        uint32_t layer_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -58990,13 +64814,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RectLayerKHR & setOffset( VULKAN_HPP_NAMESPACE::Offset2D offset_ ) VULKAN_HPP_NOEXCEPT
+    RectLayerKHR & setOffset( VULKAN_HPP_NAMESPACE::Offset2D const & offset_ ) VULKAN_HPP_NOEXCEPT
     {
       offset = offset_;
       return *this;
     }
 
-    RectLayerKHR & setExtent( VULKAN_HPP_NAMESPACE::Extent2D extent_ ) VULKAN_HPP_NOEXCEPT
+    RectLayerKHR & setExtent( VULKAN_HPP_NAMESPACE::Extent2D const & extent_ ) VULKAN_HPP_NOEXCEPT
     {
       extent = extent_;
       return *this;
@@ -59008,6 +64832,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRectLayerKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRectLayerKHR*>( this );
@@ -59018,6 +64843,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRectLayerKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RectLayerKHR const& ) const = default;
 #else
@@ -59034,16 +64860,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Offset2D offset = {};
     VULKAN_HPP_NAMESPACE::Extent2D extent = {};
     uint32_t layer = {};
+
   };
   static_assert( sizeof( RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RectLayerKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct PresentRegionKHR
   {
+
     VULKAN_HPP_CONSTEXPR PresentRegionKHR( uint32_t rectangleCount_ = {},
                                            const VULKAN_HPP_NAMESPACE::RectLayerKHR* pRectangles_ = {} ) VULKAN_HPP_NOEXCEPT
       : rectangleCount( rectangleCount_ )
@@ -59073,6 +64903,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPresentRegionKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentRegionKHR*>( this );
@@ -59083,6 +64914,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentRegionKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PresentRegionKHR const& ) const = default;
 #else
@@ -59098,15 +64930,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t rectangleCount = {};
     const VULKAN_HPP_NAMESPACE::RectLayerKHR* pRectangles = {};
+
   };
   static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PresentRegionKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct PresentRegionsKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentRegionsKHR;
+
     VULKAN_HPP_CONSTEXPR PresentRegionsKHR( uint32_t swapchainCount_ = {},
                                             const VULKAN_HPP_NAMESPACE::PresentRegionKHR* pRegions_ = {} ) VULKAN_HPP_NOEXCEPT
       : swapchainCount( swapchainCount_ )
@@ -59148,6 +64985,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPresentRegionsKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentRegionsKHR*>( this );
@@ -59158,6 +64996,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentRegionsKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PresentRegionsKHR const& ) const = default;
 #else
@@ -59175,17 +65014,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePresentRegionsKHR;
     const void* pNext = {};
     uint32_t swapchainCount = {};
     const VULKAN_HPP_NAMESPACE::PresentRegionKHR* pRegions = {};
+
   };
   static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PresentRegionsKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePresentRegionsKHR>
+  {
+    using Type = PresentRegionsKHR;
+  };
+
   struct PresentTimeGOOGLE
   {
+
     VULKAN_HPP_CONSTEXPR PresentTimeGOOGLE( uint32_t presentID_ = {},
                                             uint64_t desiredPresentTime_ = {} ) VULKAN_HPP_NOEXCEPT
       : presentID( presentID_ )
@@ -59215,6 +65064,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPresentTimeGOOGLE const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentTimeGOOGLE*>( this );
@@ -59225,6 +65075,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentTimeGOOGLE*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PresentTimeGOOGLE const& ) const = default;
 #else
@@ -59240,15 +65091,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t presentID = {};
     uint64_t desiredPresentTime = {};
+
   };
   static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PresentTimeGOOGLE>::value, "struct wrapper is not a standard layout!" );
 
   struct PresentTimesInfoGOOGLE
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimesInfoGOOGLE;
+
     VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = {},
                                                  const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE* pTimes_ = {} ) VULKAN_HPP_NOEXCEPT
       : swapchainCount( swapchainCount_ )
@@ -59290,6 +65146,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkPresentTimesInfoGOOGLE const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPresentTimesInfoGOOGLE*>( this );
@@ -59300,6 +65157,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentTimesInfoGOOGLE*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( PresentTimesInfoGOOGLE const& ) const = default;
 #else
@@ -59317,17 +65175,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePresentTimesInfoGOOGLE;
     const void* pNext = {};
     uint32_t swapchainCount = {};
     const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE* pTimes = {};
+
   };
   static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PresentTimesInfoGOOGLE>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::ePresentTimesInfoGOOGLE>
+  {
+    using Type = PresentTimesInfoGOOGLE;
+  };
+
   struct ProtectedSubmitInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eProtectedSubmitInfo;
+
     VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( VULKAN_HPP_NAMESPACE::Bool32 protectedSubmit_ = {} ) VULKAN_HPP_NOEXCEPT
       : protectedSubmit( protectedSubmit_ )
     {}
@@ -59361,6 +65230,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkProtectedSubmitInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkProtectedSubmitInfo*>( this );
@@ -59371,6 +65241,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkProtectedSubmitInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ProtectedSubmitInfo const& ) const = default;
 #else
@@ -59387,16 +65258,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eProtectedSubmitInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 protectedSubmit = {};
+
   };
   static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ProtectedSubmitInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eProtectedSubmitInfo>
+  {
+    using Type = ProtectedSubmitInfo;
+  };
+
   struct QueryPoolCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolCreateInfo;
+
     VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags flags_ = {},
                                               VULKAN_HPP_NAMESPACE::QueryType queryType_ = VULKAN_HPP_NAMESPACE::QueryType::eOcclusion,
                                               uint32_t queryCount_ = {},
@@ -59454,6 +65336,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkQueryPoolCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueryPoolCreateInfo*>( this );
@@ -59464,6 +65347,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueryPoolCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( QueryPoolCreateInfo const& ) const = default;
 #else
@@ -59483,6 +65367,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueryPoolCreateInfo;
     const void* pNext = {};
@@ -59490,12 +65376,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::QueryType queryType = VULKAN_HPP_NAMESPACE::QueryType::eOcclusion;
     uint32_t queryCount = {};
     VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags pipelineStatistics = {};
+
   };
   static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<QueryPoolCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eQueryPoolCreateInfo>
+  {
+    using Type = QueryPoolCreateInfo;
+  };
+
   struct QueryPoolPerformanceCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolPerformanceCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR QueryPoolPerformanceCreateInfoKHR( uint32_t queueFamilyIndex_ = {},
                                                             uint32_t counterIndexCount_ = {},
                                                             const uint32_t* pCounterIndices_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -59545,6 +65440,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkQueryPoolPerformanceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>( this );
@@ -59555,6 +65451,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( QueryPoolPerformanceCreateInfoKHR const& ) const = default;
 #else
@@ -59573,18 +65470,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueryPoolPerformanceCreateInfoKHR;
     const void* pNext = {};
     uint32_t queueFamilyIndex = {};
     uint32_t counterIndexCount = {};
     const uint32_t* pCounterIndices = {};
+
   };
   static_assert( sizeof( QueryPoolPerformanceCreateInfoKHR ) == sizeof( VkQueryPoolPerformanceCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<QueryPoolPerformanceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eQueryPoolPerformanceCreateInfoKHR>
+  {
+    using Type = QueryPoolPerformanceCreateInfoKHR;
+  };
+
   struct QueryPoolPerformanceQueryCreateInfoINTEL
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL;
+
     VULKAN_HPP_CONSTEXPR QueryPoolPerformanceQueryCreateInfoINTEL( VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL performanceCountersSampling_ = VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL::eManual ) VULKAN_HPP_NOEXCEPT
       : performanceCountersSampling( performanceCountersSampling_ )
     {}
@@ -59618,6 +65526,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkQueryPoolPerformanceQueryCreateInfoINTEL const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>( this );
@@ -59628,6 +65537,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( QueryPoolPerformanceQueryCreateInfoINTEL const& ) const = default;
 #else
@@ -59644,16 +65554,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL performanceCountersSampling = VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL::eManual;
+
   };
   static_assert( sizeof( QueryPoolPerformanceQueryCreateInfoINTEL ) == sizeof( VkQueryPoolPerformanceQueryCreateInfoINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<QueryPoolPerformanceQueryCreateInfoINTEL>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL>
+  {
+    using Type = QueryPoolPerformanceQueryCreateInfoINTEL;
+  };
+
   struct QueueFamilyCheckpointPropertiesNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyCheckpointPropertiesNV;
+
     VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointPropertiesNV( VULKAN_HPP_NAMESPACE::PipelineStageFlags checkpointExecutionStageMask_ = {} ) VULKAN_HPP_NOEXCEPT
       : checkpointExecutionStageMask( checkpointExecutionStageMask_ )
     {}
@@ -59675,6 +65596,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkQueueFamilyCheckpointPropertiesNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>( this );
@@ -59685,6 +65607,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( QueueFamilyCheckpointPropertiesNV const& ) const = default;
 #else
@@ -59701,16 +65624,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::PipelineStageFlags checkpointExecutionStageMask = {};
+
   };
   static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<QueueFamilyCheckpointPropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eQueueFamilyCheckpointPropertiesNV>
+  {
+    using Type = QueueFamilyCheckpointPropertiesNV;
+  };
+
   struct QueueFamilyProperties
   {
+
     VULKAN_HPP_CONSTEXPR QueueFamilyProperties( VULKAN_HPP_NAMESPACE::QueueFlags queueFlags_ = {},
                                                 uint32_t queueCount_ = {},
                                                 uint32_t timestampValidBits_ = {},
@@ -59732,6 +65665,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkQueueFamilyProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueueFamilyProperties*>( this );
@@ -59742,6 +65676,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueueFamilyProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( QueueFamilyProperties const& ) const = default;
 #else
@@ -59759,17 +65694,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::QueueFlags queueFlags = {};
     uint32_t queueCount = {};
     uint32_t timestampValidBits = {};
     VULKAN_HPP_NAMESPACE::Extent3D minImageTransferGranularity = {};
+
   };
   static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<QueueFamilyProperties>::value, "struct wrapper is not a standard layout!" );
 
   struct QueueFamilyProperties2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyProperties2;
+
     VULKAN_HPP_CONSTEXPR QueueFamilyProperties2( VULKAN_HPP_NAMESPACE::QueueFamilyProperties queueFamilyProperties_ = {} ) VULKAN_HPP_NOEXCEPT
       : queueFamilyProperties( queueFamilyProperties_ )
     {}
@@ -59791,6 +65731,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkQueueFamilyProperties2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkQueueFamilyProperties2*>( this );
@@ -59801,6 +65742,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueueFamilyProperties2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( QueueFamilyProperties2 const& ) const = default;
 #else
@@ -59817,17 +65759,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueueFamilyProperties2;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::QueueFamilyProperties queueFamilyProperties = {};
+
   };
   static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<QueueFamilyProperties2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eQueueFamilyProperties2>
+  {
+    using Type = QueueFamilyProperties2;
+  };
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct RayTracingShaderGroupCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingShaderGroupCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoKHR( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR type_ = VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR::eGeneral,
                                                              uint32_t generalShader_ = {},
                                                              uint32_t closestHitShader_ = {},
@@ -59901,6 +65854,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRayTracingShaderGroupCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoKHR*>( this );
@@ -59911,6 +65865,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RayTracingShaderGroupCreateInfoKHR const& ) const = default;
 #else
@@ -59932,6 +65887,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoKHR;
     const void* pNext = {};
@@ -59941,14 +65898,23 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t anyHitShader = {};
     uint32_t intersectionShader = {};
     const void* pShaderGroupCaptureReplayHandle = {};
+
   };
   static_assert( sizeof( RayTracingShaderGroupCreateInfoKHR ) == sizeof( VkRayTracingShaderGroupCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RayTracingShaderGroupCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eRayTracingShaderGroupCreateInfoKHR>
+  {
+    using Type = RayTracingShaderGroupCreateInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct RayTracingPipelineInterfaceCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineInterfaceCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR RayTracingPipelineInterfaceCreateInfoKHR( uint32_t maxPayloadSize_ = {},
                                                                    uint32_t maxAttributeSize_ = {},
                                                                    uint32_t maxCallableSize_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -59998,6 +65964,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRayTracingPipelineInterfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRayTracingPipelineInterfaceCreateInfoKHR*>( this );
@@ -60008,6 +65975,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRayTracingPipelineInterfaceCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RayTracingPipelineInterfaceCreateInfoKHR const& ) const = default;
 #else
@@ -60026,20 +65994,31 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingPipelineInterfaceCreateInfoKHR;
     const void* pNext = {};
     uint32_t maxPayloadSize = {};
     uint32_t maxAttributeSize = {};
     uint32_t maxCallableSize = {};
+
   };
   static_assert( sizeof( RayTracingPipelineInterfaceCreateInfoKHR ) == sizeof( VkRayTracingPipelineInterfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RayTracingPipelineInterfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eRayTracingPipelineInterfaceCreateInfoKHR>
+  {
+    using Type = RayTracingPipelineInterfaceCreateInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct RayTracingPipelineCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoKHR( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {},
                                                           uint32_t stageCount_ = {},
                                                           const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages_ = {},
@@ -60123,7 +66102,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RayTracingPipelineCreateInfoKHR & setLibraries( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR libraries_ ) VULKAN_HPP_NOEXCEPT
+    RayTracingPipelineCreateInfoKHR & setLibraries( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & libraries_ ) VULKAN_HPP_NOEXCEPT
     {
       libraries = libraries_;
       return *this;
@@ -60153,6 +66132,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRayTracingPipelineCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR*>( this );
@@ -60163,6 +66143,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRayTracingPipelineCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RayTracingPipelineCreateInfoKHR const& ) const = default;
 #else
@@ -60189,6 +66170,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingPipelineCreateInfoKHR;
     const void* pNext = {};
@@ -60203,13 +66186,22 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::PipelineLayout layout = {};
     VULKAN_HPP_NAMESPACE::Pipeline basePipelineHandle = {};
     int32_t basePipelineIndex = {};
+
   };
   static_assert( sizeof( RayTracingPipelineCreateInfoKHR ) == sizeof( VkRayTracingPipelineCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RayTracingPipelineCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eRayTracingPipelineCreateInfoKHR>
+  {
+    using Type = RayTracingPipelineCreateInfoKHR;
+  };
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   struct RayTracingShaderGroupCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingShaderGroupCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR type_ = VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR::eGeneral,
                                                             uint32_t generalShader_ = {},
                                                             uint32_t closestHitShader_ = {},
@@ -60275,6 +66267,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRayTracingShaderGroupCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV*>( this );
@@ -60285,6 +66278,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RayTracingShaderGroupCreateInfoNV const& ) const = default;
 #else
@@ -60305,6 +66299,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV;
     const void* pNext = {};
@@ -60313,12 +66309,21 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t closestHitShader = {};
     uint32_t anyHitShader = {};
     uint32_t intersectionShader = {};
+
   };
   static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RayTracingShaderGroupCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eRayTracingShaderGroupCreateInfoNV>
+  {
+    using Type = RayTracingShaderGroupCreateInfoNV;
+  };
+
   struct RayTracingPipelineCreateInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineCreateInfoNV;
+
     VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {},
                                                          uint32_t stageCount_ = {},
                                                          const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages_ = {},
@@ -60416,6 +66421,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRayTracingPipelineCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( this );
@@ -60426,6 +66432,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RayTracingPipelineCreateInfoNV const& ) const = default;
 #else
@@ -60450,6 +66457,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV;
     const void* pNext = {};
@@ -60462,12 +66471,20 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::PipelineLayout layout = {};
     VULKAN_HPP_NAMESPACE::Pipeline basePipelineHandle = {};
     int32_t basePipelineIndex = {};
+
   };
   static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RayTracingPipelineCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eRayTracingPipelineCreateInfoNV>
+  {
+    using Type = RayTracingPipelineCreateInfoNV;
+  };
+
   struct RefreshCycleDurationGOOGLE
   {
+
     VULKAN_HPP_CONSTEXPR RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = {} ) VULKAN_HPP_NOEXCEPT
       : refreshDuration( refreshDuration_ )
     {}
@@ -60483,6 +66500,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRefreshCycleDurationGOOGLE const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE*>( this );
@@ -60493,6 +66511,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RefreshCycleDurationGOOGLE const& ) const = default;
 #else
@@ -60507,14 +66526,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint64_t refreshDuration = {};
+
   };
   static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RefreshCycleDurationGOOGLE>::value, "struct wrapper is not a standard layout!" );
 
   struct RenderPassAttachmentBeginInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassAttachmentBeginInfo;
+
     VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfo( uint32_t attachmentCount_ = {},
                                                         const VULKAN_HPP_NAMESPACE::ImageView* pAttachments_ = {} ) VULKAN_HPP_NOEXCEPT
       : attachmentCount( attachmentCount_ )
@@ -60556,6 +66580,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRenderPassAttachmentBeginInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>( this );
@@ -60566,6 +66591,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassAttachmentBeginInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RenderPassAttachmentBeginInfo const& ) const = default;
 #else
@@ -60583,17 +66609,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassAttachmentBeginInfo;
     const void* pNext = {};
     uint32_t attachmentCount = {};
     const VULKAN_HPP_NAMESPACE::ImageView* pAttachments = {};
+
   };
   static_assert( sizeof( RenderPassAttachmentBeginInfo ) == sizeof( VkRenderPassAttachmentBeginInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassAttachmentBeginInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eRenderPassAttachmentBeginInfo>
+  {
+    using Type = RenderPassAttachmentBeginInfo;
+  };
+
   struct RenderPassBeginInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassBeginInfo;
+
     VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo( VULKAN_HPP_NAMESPACE::RenderPass renderPass_ = {},
                                                  VULKAN_HPP_NAMESPACE::Framebuffer framebuffer_ = {},
                                                  VULKAN_HPP_NAMESPACE::Rect2D renderArea_ = {},
@@ -60641,7 +66678,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassBeginInfo & setRenderArea( VULKAN_HPP_NAMESPACE::Rect2D renderArea_ ) VULKAN_HPP_NOEXCEPT
+    RenderPassBeginInfo & setRenderArea( VULKAN_HPP_NAMESPACE::Rect2D const & renderArea_ ) VULKAN_HPP_NOEXCEPT
     {
       renderArea = renderArea_;
       return *this;
@@ -60659,6 +66696,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRenderPassBeginInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassBeginInfo*>( this );
@@ -60669,6 +66707,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassBeginInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RenderPassBeginInfo const& ) const = default;
 #else
@@ -60689,6 +66728,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassBeginInfo;
     const void* pNext = {};
@@ -60697,12 +66738,20 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::Rect2D renderArea = {};
     uint32_t clearValueCount = {};
     const VULKAN_HPP_NAMESPACE::ClearValue* pClearValues = {};
+
   };
   static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassBeginInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eRenderPassBeginInfo>
+  {
+    using Type = RenderPassBeginInfo;
+  };
+
   struct SubpassDescription
   {
+
     VULKAN_HPP_CONSTEXPR SubpassDescription( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags_ = {},
                                              VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics,
                                              uint32_t inputAttachmentCount_ = {},
@@ -60796,6 +66845,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSubpassDescription const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassDescription*>( this );
@@ -60806,6 +66856,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassDescription*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SubpassDescription const& ) const = default;
 #else
@@ -60829,6 +66880,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags = {};
     VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics;
@@ -60840,12 +66893,14 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::AttachmentReference* pDepthStencilAttachment = {};
     uint32_t preserveAttachmentCount = {};
     const uint32_t* pPreserveAttachments = {};
+
   };
   static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SubpassDescription>::value, "struct wrapper is not a standard layout!" );
 
   struct SubpassDependency
   {
+
     VULKAN_HPP_CONSTEXPR SubpassDependency( uint32_t srcSubpass_ = {},
                                             uint32_t dstSubpass_ = {},
                                             VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask_ = {},
@@ -60915,6 +66970,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSubpassDependency const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassDependency*>( this );
@@ -60925,6 +66981,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassDependency*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SubpassDependency const& ) const = default;
 #else
@@ -60945,6 +67002,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t srcSubpass = {};
     uint32_t dstSubpass = {};
@@ -60953,12 +67012,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask = {};
     VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask = {};
     VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags = {};
+
   };
   static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SubpassDependency>::value, "struct wrapper is not a standard layout!" );
 
   struct RenderPassCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreateInfo;
+
     VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags_ = {},
                                                uint32_t attachmentCount_ = {},
                                                const VULKAN_HPP_NAMESPACE::AttachmentDescription* pAttachments_ = {},
@@ -61040,6 +67102,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRenderPassCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassCreateInfo*>( this );
@@ -61050,6 +67113,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RenderPassCreateInfo const& ) const = default;
 #else
@@ -61072,6 +67136,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassCreateInfo;
     const void* pNext = {};
@@ -61082,12 +67148,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::SubpassDescription* pSubpasses = {};
     uint32_t dependencyCount = {};
     const VULKAN_HPP_NAMESPACE::SubpassDependency* pDependencies = {};
+
   };
   static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eRenderPassCreateInfo>
+  {
+    using Type = RenderPassCreateInfo;
+  };
+
   struct SubpassDescription2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDescription2;
+
     VULKAN_HPP_CONSTEXPR SubpassDescription2( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags_ = {},
                                               VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics,
                                               uint32_t viewMask_ = {},
@@ -61201,6 +67276,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSubpassDescription2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassDescription2*>( this );
@@ -61211,6 +67287,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassDescription2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SubpassDescription2 const& ) const = default;
 #else
@@ -61237,6 +67314,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassDescription2;
     const void* pNext = {};
@@ -61251,12 +67330,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::AttachmentReference2* pDepthStencilAttachment = {};
     uint32_t preserveAttachmentCount = {};
     const uint32_t* pPreserveAttachments = {};
+
   };
   static_assert( sizeof( SubpassDescription2 ) == sizeof( VkSubpassDescription2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SubpassDescription2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSubpassDescription2>
+  {
+    using Type = SubpassDescription2;
+  };
+
   struct SubpassDependency2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDependency2;
+
     VULKAN_HPP_CONSTEXPR SubpassDependency2( uint32_t srcSubpass_ = {},
                                              uint32_t dstSubpass_ = {},
                                              VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask_ = {},
@@ -61346,6 +67434,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSubpassDependency2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassDependency2*>( this );
@@ -61356,6 +67445,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassDependency2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SubpassDependency2 const& ) const = default;
 #else
@@ -61379,6 +67469,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassDependency2;
     const void* pNext = {};
@@ -61390,12 +67482,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask = {};
     VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags = {};
     int32_t viewOffset = {};
+
   };
   static_assert( sizeof( SubpassDependency2 ) == sizeof( VkSubpassDependency2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SubpassDependency2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSubpassDependency2>
+  {
+    using Type = SubpassDependency2;
+  };
+
   struct RenderPassCreateInfo2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreateInfo2;
+
     VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags_ = {},
                                                 uint32_t attachmentCount_ = {},
                                                 const VULKAN_HPP_NAMESPACE::AttachmentDescription2* pAttachments_ = {},
@@ -61493,6 +67594,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRenderPassCreateInfo2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassCreateInfo2*>( this );
@@ -61503,6 +67605,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassCreateInfo2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RenderPassCreateInfo2 const& ) const = default;
 #else
@@ -61527,6 +67630,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassCreateInfo2;
     const void* pNext = {};
@@ -61539,12 +67644,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::SubpassDependency2* pDependencies = {};
     uint32_t correlatedViewMaskCount = {};
     const uint32_t* pCorrelatedViewMasks = {};
+
   };
   static_assert( sizeof( RenderPassCreateInfo2 ) == sizeof( VkRenderPassCreateInfo2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassCreateInfo2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eRenderPassCreateInfo2>
+  {
+    using Type = RenderPassCreateInfo2;
+  };
+
   struct RenderPassFragmentDensityMapCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( VULKAN_HPP_NAMESPACE::AttachmentReference fragmentDensityMapAttachment_ = {} ) VULKAN_HPP_NOEXCEPT
       : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
     {}
@@ -61572,12 +67686,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassFragmentDensityMapCreateInfoEXT & setFragmentDensityMapAttachment( VULKAN_HPP_NAMESPACE::AttachmentReference fragmentDensityMapAttachment_ ) VULKAN_HPP_NOEXCEPT
+    RenderPassFragmentDensityMapCreateInfoEXT & setFragmentDensityMapAttachment( VULKAN_HPP_NAMESPACE::AttachmentReference const & fragmentDensityMapAttachment_ ) VULKAN_HPP_NOEXCEPT
     {
       fragmentDensityMapAttachment = fragmentDensityMapAttachment_;
       return *this;
     }
 
+
     operator VkRenderPassFragmentDensityMapCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>( this );
@@ -61588,6 +67703,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RenderPassFragmentDensityMapCreateInfoEXT const& ) const = default;
 #else
@@ -61604,16 +67720,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::AttachmentReference fragmentDensityMapAttachment = {};
+
   };
   static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassFragmentDensityMapCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eRenderPassFragmentDensityMapCreateInfoEXT>
+  {
+    using Type = RenderPassFragmentDensityMapCreateInfoEXT;
+  };
+
   struct RenderPassInputAttachmentAspectCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
+
     VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = {},
                                                                     const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference* pAspectReferences_ = {} ) VULKAN_HPP_NOEXCEPT
       : aspectReferenceCount( aspectReferenceCount_ )
@@ -61655,6 +67782,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRenderPassInputAttachmentAspectCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>( this );
@@ -61665,6 +67793,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RenderPassInputAttachmentAspectCreateInfo const& ) const = default;
 #else
@@ -61682,17 +67811,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
     const void* pNext = {};
     uint32_t aspectReferenceCount = {};
     const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference* pAspectReferences = {};
+
   };
   static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassInputAttachmentAspectCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eRenderPassInputAttachmentAspectCreateInfo>
+  {
+    using Type = RenderPassInputAttachmentAspectCreateInfo;
+  };
+
   struct RenderPassMultiviewCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassMultiviewCreateInfo;
+
     VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = {},
                                                         const uint32_t* pViewMasks_ = {},
                                                         uint32_t dependencyCount_ = {},
@@ -61766,6 +67906,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRenderPassMultiviewCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>( this );
@@ -61776,6 +67917,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RenderPassMultiviewCreateInfo const& ) const = default;
 #else
@@ -61797,6 +67939,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassMultiviewCreateInfo;
     const void* pNext = {};
@@ -61806,12 +67950,20 @@ namespace VULKAN_HPP_NAMESPACE
     const int32_t* pViewOffsets = {};
     uint32_t correlationMaskCount = {};
     const uint32_t* pCorrelationMasks = {};
+
   };
   static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassMultiviewCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eRenderPassMultiviewCreateInfo>
+  {
+    using Type = RenderPassMultiviewCreateInfo;
+  };
+
   struct SubpassSampleLocationsEXT
   {
+
     VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( uint32_t subpassIndex_ = {},
                                                     VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT
       : subpassIndex( subpassIndex_ )
@@ -61835,12 +67987,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassSampleLocationsEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT
+    SubpassSampleLocationsEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT
     {
       sampleLocationsInfo = sampleLocationsInfo_;
       return *this;
     }
 
+
     operator VkSubpassSampleLocationsEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassSampleLocationsEXT*>( this );
@@ -61851,6 +68004,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassSampleLocationsEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SubpassSampleLocationsEXT const& ) const = default;
 #else
@@ -61866,15 +68020,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t subpassIndex = {};
     VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo = {};
+
   };
   static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SubpassSampleLocationsEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct RenderPassSampleLocationsBeginInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
+
     VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = {},
                                                                 const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = {},
                                                                 uint32_t postSubpassSampleLocationsCount_ = {},
@@ -61932,6 +68091,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRenderPassSampleLocationsBeginInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>( this );
@@ -61942,6 +68102,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RenderPassSampleLocationsBeginInfoEXT const& ) const = default;
 #else
@@ -61961,6 +68122,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
     const void* pNext = {};
@@ -61968,12 +68131,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations = {};
     uint32_t postSubpassSampleLocationsCount = {};
     const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT* pPostSubpassSampleLocations = {};
+
   };
   static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassSampleLocationsBeginInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eRenderPassSampleLocationsBeginInfoEXT>
+  {
+    using Type = RenderPassSampleLocationsBeginInfoEXT;
+  };
+
   struct RenderPassTransformBeginInfoQCOM
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassTransformBeginInfoQCOM;
+
     VULKAN_HPP_CONSTEXPR RenderPassTransformBeginInfoQCOM( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform_ = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity ) VULKAN_HPP_NOEXCEPT
       : transform( transform_ )
     {}
@@ -62007,6 +68179,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkRenderPassTransformBeginInfoQCOM const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>( this );
@@ -62017,6 +68190,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( RenderPassTransformBeginInfoQCOM const& ) const = default;
 #else
@@ -62033,16 +68207,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassTransformBeginInfoQCOM;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity;
+
   };
   static_assert( sizeof( RenderPassTransformBeginInfoQCOM ) == sizeof( VkRenderPassTransformBeginInfoQCOM ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassTransformBeginInfoQCOM>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eRenderPassTransformBeginInfoQCOM>
+  {
+    using Type = RenderPassTransformBeginInfoQCOM;
+  };
+
   struct SamplerCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCreateInfo;
+
     VULKAN_HPP_CONSTEXPR SamplerCreateInfo( VULKAN_HPP_NAMESPACE::SamplerCreateFlags flags_ = {},
                                             VULKAN_HPP_NAMESPACE::Filter magFilter_ = VULKAN_HPP_NAMESPACE::Filter::eNearest,
                                             VULKAN_HPP_NAMESPACE::Filter minFilter_ = VULKAN_HPP_NAMESPACE::Filter::eNearest,
@@ -62196,6 +68381,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSamplerCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerCreateInfo*>( this );
@@ -62206,6 +68392,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SamplerCreateInfo const& ) const = default;
 #else
@@ -62237,6 +68424,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerCreateInfo;
     const void* pNext = {};
@@ -62256,12 +68445,21 @@ namespace VULKAN_HPP_NAMESPACE
     float maxLod = {};
     VULKAN_HPP_NAMESPACE::BorderColor borderColor = VULKAN_HPP_NAMESPACE::BorderColor::eFloatTransparentBlack;
     VULKAN_HPP_NAMESPACE::Bool32 unnormalizedCoordinates = {};
+
   };
   static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SamplerCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSamplerCreateInfo>
+  {
+    using Type = SamplerCreateInfo;
+  };
+
   struct SamplerReductionModeCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerReductionModeCreateInfo;
+
     VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfo( VULKAN_HPP_NAMESPACE::SamplerReductionMode reductionMode_ = VULKAN_HPP_NAMESPACE::SamplerReductionMode::eWeightedAverage ) VULKAN_HPP_NOEXCEPT
       : reductionMode( reductionMode_ )
     {}
@@ -62295,6 +68493,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSamplerReductionModeCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerReductionModeCreateInfo*>( this );
@@ -62305,6 +68504,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerReductionModeCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SamplerReductionModeCreateInfo const& ) const = default;
 #else
@@ -62321,16 +68521,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerReductionModeCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::SamplerReductionMode reductionMode = VULKAN_HPP_NAMESPACE::SamplerReductionMode::eWeightedAverage;
+
   };
   static_assert( sizeof( SamplerReductionModeCreateInfo ) == sizeof( VkSamplerReductionModeCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SamplerReductionModeCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSamplerReductionModeCreateInfo>
+  {
+    using Type = SamplerReductionModeCreateInfo;
+  };
+
   struct SamplerYcbcrConversionCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionCreateInfo;
+
     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
                                                            VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion ycbcrModel_ = VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion::eRgbIdentity,
                                                            VULKAN_HPP_NAMESPACE::SamplerYcbcrRange ycbcrRange_ = VULKAN_HPP_NAMESPACE::SamplerYcbcrRange::eItuFull,
@@ -62390,7 +68601,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo & setComponents( VULKAN_HPP_NAMESPACE::ComponentMapping components_ ) VULKAN_HPP_NOEXCEPT
+    SamplerYcbcrConversionCreateInfo & setComponents( VULKAN_HPP_NAMESPACE::ComponentMapping const & components_ ) VULKAN_HPP_NOEXCEPT
     {
       components = components_;
       return *this;
@@ -62420,6 +68631,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSamplerYcbcrConversionCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( this );
@@ -62430,6 +68642,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SamplerYcbcrConversionCreateInfo const& ) const = default;
 #else
@@ -62453,6 +68666,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo;
     const void* pNext = {};
@@ -62464,12 +68679,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ChromaLocation yChromaOffset = VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven;
     VULKAN_HPP_NAMESPACE::Filter chromaFilter = VULKAN_HPP_NAMESPACE::Filter::eNearest;
     VULKAN_HPP_NAMESPACE::Bool32 forceExplicitReconstruction = {};
+
   };
   static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SamplerYcbcrConversionCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSamplerYcbcrConversionCreateInfo>
+  {
+    using Type = SamplerYcbcrConversionCreateInfo;
+  };
+
   struct SamplerYcbcrConversionImageFormatProperties
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionImageFormatProperties;
+
     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionImageFormatProperties( uint32_t combinedImageSamplerDescriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT
       : combinedImageSamplerDescriptorCount( combinedImageSamplerDescriptorCount_ )
     {}
@@ -62491,6 +68715,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSamplerYcbcrConversionImageFormatProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>( this );
@@ -62501,6 +68726,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SamplerYcbcrConversionImageFormatProperties const& ) const = default;
 #else
@@ -62517,16 +68743,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties;
     void* pNext = {};
     uint32_t combinedImageSamplerDescriptorCount = {};
+
   };
   static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SamplerYcbcrConversionImageFormatProperties>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSamplerYcbcrConversionImageFormatProperties>
+  {
+    using Type = SamplerYcbcrConversionImageFormatProperties;
+  };
+
   struct SamplerYcbcrConversionInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionInfo;
+
     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion conversion_ = {} ) VULKAN_HPP_NOEXCEPT
       : conversion( conversion_ )
     {}
@@ -62560,6 +68797,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSamplerYcbcrConversionInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSamplerYcbcrConversionInfo*>( this );
@@ -62570,6 +68808,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerYcbcrConversionInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SamplerYcbcrConversionInfo const& ) const = default;
 #else
@@ -62586,16 +68825,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerYcbcrConversionInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion conversion = {};
+
   };
   static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SamplerYcbcrConversionInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSamplerYcbcrConversionInfo>
+  {
+    using Type = SamplerYcbcrConversionInfo;
+  };
+
   struct SemaphoreCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreCreateInfo;
+
     VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
     {}
@@ -62629,6 +68879,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSemaphoreCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreCreateInfo*>( this );
@@ -62639,6 +68890,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SemaphoreCreateInfo const& ) const = default;
 #else
@@ -62655,16 +68907,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags flags = {};
+
   };
   static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SemaphoreCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSemaphoreCreateInfo>
+  {
+    using Type = SemaphoreCreateInfo;
+  };
+
   struct SemaphoreGetFdInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetFdInfoKHR;
+
     VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {},
                                                 VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
       : semaphore( semaphore_ )
@@ -62706,6 +68969,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSemaphoreGetFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( this );
@@ -62716,6 +68980,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SemaphoreGetFdInfoKHR const& ) const = default;
 #else
@@ -62733,18 +68998,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Semaphore semaphore = {};
     VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd;
+
   };
   static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SemaphoreGetFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSemaphoreGetFdInfoKHR>
+  {
+    using Type = SemaphoreGetFdInfoKHR;
+  };
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct SemaphoreGetWin32HandleInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
+
     VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {},
                                                          VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
       : semaphore( semaphore_ )
@@ -62786,6 +69062,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSemaphoreGetWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( this );
@@ -62796,6 +69073,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SemaphoreGetWin32HandleInfoKHR const& ) const = default;
 #else
@@ -62813,18 +69091,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Semaphore semaphore = {};
     VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd;
+
   };
   static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SemaphoreGetWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eSemaphoreGetWin32HandleInfoKHR>
+  {
+    using Type = SemaphoreGetWin32HandleInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct SemaphoreSignalInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreSignalInfo;
+
     VULKAN_HPP_CONSTEXPR SemaphoreSignalInfo( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {},
                                               uint64_t value_ = {} ) VULKAN_HPP_NOEXCEPT
       : semaphore( semaphore_ )
@@ -62866,6 +69155,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSemaphoreSignalInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreSignalInfo*>( this );
@@ -62876,6 +69166,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreSignalInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SemaphoreSignalInfo const& ) const = default;
 #else
@@ -62893,17 +69184,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreSignalInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Semaphore semaphore = {};
     uint64_t value = {};
+
   };
   static_assert( sizeof( SemaphoreSignalInfo ) == sizeof( VkSemaphoreSignalInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SemaphoreSignalInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSemaphoreSignalInfo>
+  {
+    using Type = SemaphoreSignalInfo;
+  };
+
   struct SemaphoreTypeCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreTypeCreateInfo;
+
     VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfo( VULKAN_HPP_NAMESPACE::SemaphoreType semaphoreType_ = VULKAN_HPP_NAMESPACE::SemaphoreType::eBinary,
                                                   uint64_t initialValue_ = {} ) VULKAN_HPP_NOEXCEPT
       : semaphoreType( semaphoreType_ )
@@ -62945,6 +69247,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSemaphoreTypeCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreTypeCreateInfo*>( this );
@@ -62955,6 +69258,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreTypeCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SemaphoreTypeCreateInfo const& ) const = default;
 #else
@@ -62972,17 +69276,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreTypeCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::SemaphoreType semaphoreType = VULKAN_HPP_NAMESPACE::SemaphoreType::eBinary;
     uint64_t initialValue = {};
+
   };
   static_assert( sizeof( SemaphoreTypeCreateInfo ) == sizeof( VkSemaphoreTypeCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SemaphoreTypeCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSemaphoreTypeCreateInfo>
+  {
+    using Type = SemaphoreTypeCreateInfo;
+  };
+
   struct SemaphoreWaitInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreWaitInfo;
+
     VULKAN_HPP_CONSTEXPR SemaphoreWaitInfo( VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags flags_ = {},
                                             uint32_t semaphoreCount_ = {},
                                             const VULKAN_HPP_NAMESPACE::Semaphore* pSemaphores_ = {},
@@ -63040,6 +69355,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSemaphoreWaitInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSemaphoreWaitInfo*>( this );
@@ -63050,6 +69366,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreWaitInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SemaphoreWaitInfo const& ) const = default;
 #else
@@ -63069,6 +69386,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreWaitInfo;
     const void* pNext = {};
@@ -63076,12 +69395,20 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t semaphoreCount = {};
     const VULKAN_HPP_NAMESPACE::Semaphore* pSemaphores = {};
     const uint64_t* pValues = {};
+
   };
   static_assert( sizeof( SemaphoreWaitInfo ) == sizeof( VkSemaphoreWaitInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SemaphoreWaitInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSemaphoreWaitInfo>
+  {
+    using Type = SemaphoreWaitInfo;
+  };
+
   struct SetStateFlagsIndirectCommandNV
   {
+
     VULKAN_HPP_CONSTEXPR SetStateFlagsIndirectCommandNV( uint32_t data_ = {} ) VULKAN_HPP_NOEXCEPT
       : data( data_ )
     {}
@@ -63103,6 +69430,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSetStateFlagsIndirectCommandNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSetStateFlagsIndirectCommandNV*>( this );
@@ -63113,6 +69441,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSetStateFlagsIndirectCommandNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SetStateFlagsIndirectCommandNV const& ) const = default;
 #else
@@ -63127,14 +69456,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t data = {};
+
   };
   static_assert( sizeof( SetStateFlagsIndirectCommandNV ) == sizeof( VkSetStateFlagsIndirectCommandNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SetStateFlagsIndirectCommandNV>::value, "struct wrapper is not a standard layout!" );
 
   struct ShaderModuleCreateInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderModuleCreateInfo;
+
     VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags flags_ = {},
                                                  size_t codeSize_ = {},
                                                  const uint32_t* pCode_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -63184,6 +69518,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkShaderModuleCreateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkShaderModuleCreateInfo*>( this );
@@ -63194,6 +69529,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkShaderModuleCreateInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ShaderModuleCreateInfo const& ) const = default;
 #else
@@ -63212,18 +69548,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eShaderModuleCreateInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags flags = {};
     size_t codeSize = {};
     const uint32_t* pCode = {};
+
   };
   static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ShaderModuleCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eShaderModuleCreateInfo>
+  {
+    using Type = ShaderModuleCreateInfo;
+  };
+
   struct ShaderModuleValidationCacheCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache_ = {} ) VULKAN_HPP_NOEXCEPT
       : validationCache( validationCache_ )
     {}
@@ -63257,6 +69604,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkShaderModuleValidationCacheCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>( this );
@@ -63267,6 +69615,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ShaderModuleValidationCacheCreateInfoEXT const& ) const = default;
 #else
@@ -63283,16 +69632,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache = {};
+
   };
   static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ShaderModuleValidationCacheCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eShaderModuleValidationCacheCreateInfoEXT>
+  {
+    using Type = ShaderModuleValidationCacheCreateInfoEXT;
+  };
+
   struct ShaderResourceUsageAMD
   {
+
     VULKAN_HPP_CONSTEXPR ShaderResourceUsageAMD( uint32_t numUsedVgprs_ = {},
                                                  uint32_t numUsedSgprs_ = {},
                                                  uint32_t ldsSizePerLocalWorkGroup_ = {},
@@ -63316,6 +69675,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkShaderResourceUsageAMD const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkShaderResourceUsageAMD*>( this );
@@ -63326,6 +69686,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkShaderResourceUsageAMD*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ShaderResourceUsageAMD const& ) const = default;
 #else
@@ -63344,18 +69705,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t numUsedVgprs = {};
     uint32_t numUsedSgprs = {};
     uint32_t ldsSizePerLocalWorkGroup = {};
     size_t ldsUsageSizeInBytes = {};
     size_t scratchMemUsageInBytes = {};
+
   };
   static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ShaderResourceUsageAMD>::value, "struct wrapper is not a standard layout!" );
 
   struct ShaderStatisticsInfoAMD
   {
+
     VULKAN_HPP_CONSTEXPR_14 ShaderStatisticsInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlags shaderStageMask_ = {},
                                                      VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD resourceUsage_ = {},
                                                      uint32_t numPhysicalVgprs_ = {},
@@ -63383,6 +69748,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkShaderStatisticsInfoAMD const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>( this );
@@ -63393,6 +69759,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkShaderStatisticsInfoAMD*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ShaderStatisticsInfoAMD const& ) const = default;
 #else
@@ -63413,6 +69780,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ShaderStageFlags shaderStageMask = {};
     VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD resourceUsage = {};
@@ -63421,12 +69790,15 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t numAvailableVgprs = {};
     uint32_t numAvailableSgprs = {};
     VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> computeWorkGroupSize = {};
+
   };
   static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ShaderStatisticsInfoAMD>::value, "struct wrapper is not a standard layout!" );
 
   struct SharedPresentSurfaceCapabilitiesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
+
     VULKAN_HPP_CONSTEXPR SharedPresentSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::ImageUsageFlags sharedPresentSupportedUsageFlags_ = {} ) VULKAN_HPP_NOEXCEPT
       : sharedPresentSupportedUsageFlags( sharedPresentSupportedUsageFlags_ )
     {}
@@ -63448,6 +69820,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSharedPresentSurfaceCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>( this );
@@ -63458,6 +69831,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SharedPresentSurfaceCapabilitiesKHR const& ) const = default;
 #else
@@ -63474,16 +69848,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::ImageUsageFlags sharedPresentSupportedUsageFlags = {};
+
   };
   static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SharedPresentSurfaceCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSharedPresentSurfaceCapabilitiesKHR>
+  {
+    using Type = SharedPresentSurfaceCapabilitiesKHR;
+  };
+
   struct SparseImageFormatProperties
   {
+
     VULKAN_HPP_CONSTEXPR SparseImageFormatProperties( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {},
                                                       VULKAN_HPP_NAMESPACE::Extent3D imageGranularity_ = {},
                                                       VULKAN_HPP_NAMESPACE::SparseImageFormatFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -63503,6 +69887,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSparseImageFormatProperties const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageFormatProperties*>( this );
@@ -63513,6 +69898,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageFormatProperties*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SparseImageFormatProperties const& ) const = default;
 #else
@@ -63529,16 +69915,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {};
     VULKAN_HPP_NAMESPACE::Extent3D imageGranularity = {};
     VULKAN_HPP_NAMESPACE::SparseImageFormatFlags flags = {};
+
   };
   static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SparseImageFormatProperties>::value, "struct wrapper is not a standard layout!" );
 
   struct SparseImageFormatProperties2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSparseImageFormatProperties2;
+
     VULKAN_HPP_CONSTEXPR SparseImageFormatProperties2( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties properties_ = {} ) VULKAN_HPP_NOEXCEPT
       : properties( properties_ )
     {}
@@ -63560,6 +69951,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSparseImageFormatProperties2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageFormatProperties2*>( this );
@@ -63570,6 +69962,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageFormatProperties2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SparseImageFormatProperties2 const& ) const = default;
 #else
@@ -63586,16 +69979,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSparseImageFormatProperties2;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::SparseImageFormatProperties properties = {};
+
   };
   static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SparseImageFormatProperties2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSparseImageFormatProperties2>
+  {
+    using Type = SparseImageFormatProperties2;
+  };
+
   struct SparseImageMemoryRequirements
   {
+
     VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties formatProperties_ = {},
                                                         uint32_t imageMipTailFirstLod_ = {},
                                                         VULKAN_HPP_NAMESPACE::DeviceSize imageMipTailSize_ = {},
@@ -63619,6 +70022,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSparseImageMemoryRequirements const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageMemoryRequirements*>( this );
@@ -63629,6 +70033,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageMemoryRequirements*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SparseImageMemoryRequirements const& ) const = default;
 #else
@@ -63647,18 +70052,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::SparseImageFormatProperties formatProperties = {};
     uint32_t imageMipTailFirstLod = {};
     VULKAN_HPP_NAMESPACE::DeviceSize imageMipTailSize = {};
     VULKAN_HPP_NAMESPACE::DeviceSize imageMipTailOffset = {};
     VULKAN_HPP_NAMESPACE::DeviceSize imageMipTailStride = {};
+
   };
   static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SparseImageMemoryRequirements>::value, "struct wrapper is not a standard layout!" );
 
   struct SparseImageMemoryRequirements2
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSparseImageMemoryRequirements2;
+
     VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements2( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements memoryRequirements_ = {} ) VULKAN_HPP_NOEXCEPT
       : memoryRequirements( memoryRequirements_ )
     {}
@@ -63680,6 +70090,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSparseImageMemoryRequirements2 const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSparseImageMemoryRequirements2*>( this );
@@ -63690,6 +70101,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageMemoryRequirements2*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SparseImageMemoryRequirements2 const& ) const = default;
 #else
@@ -63706,17 +70118,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSparseImageMemoryRequirements2;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements memoryRequirements = {};
+
   };
   static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SparseImageMemoryRequirements2>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSparseImageMemoryRequirements2>
+  {
+    using Type = SparseImageMemoryRequirements2;
+  };
+
 #ifdef VK_USE_PLATFORM_GGP
   struct StreamDescriptorSurfaceCreateInfoGGP
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP;
+
     VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP flags_ = {},
                                                                GgpStreamDescriptor streamDescriptor_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -63758,6 +70181,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkStreamDescriptorSurfaceCreateInfoGGP const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( this );
@@ -63768,6 +70192,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( StreamDescriptorSurfaceCreateInfoGGP const& ) const = default;
 #else
@@ -63785,19 +70210,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP flags = {};
     GgpStreamDescriptor streamDescriptor = {};
+
   };
   static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<StreamDescriptorSurfaceCreateInfoGGP>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eStreamDescriptorSurfaceCreateInfoGGP>
+  {
+    using Type = StreamDescriptorSurfaceCreateInfoGGP;
+  };
 #endif /*VK_USE_PLATFORM_GGP*/
 
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct StridedBufferRegionKHR
   {
+
     VULKAN_HPP_CONSTEXPR StridedBufferRegionKHR( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {},
                                                  VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {},
                                                  VULKAN_HPP_NAMESPACE::DeviceSize stride_ = {},
@@ -63852,6 +70287,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkStridedBufferRegionKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkStridedBufferRegionKHR*>( this );
@@ -63862,6 +70298,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkStridedBufferRegionKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( StridedBufferRegionKHR const& ) const = default;
 #else
@@ -63879,11 +70316,14 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Buffer buffer = {};
     VULKAN_HPP_NAMESPACE::DeviceSize offset = {};
     VULKAN_HPP_NAMESPACE::DeviceSize stride = {};
     VULKAN_HPP_NAMESPACE::DeviceSize size = {};
+
   };
   static_assert( sizeof( StridedBufferRegionKHR ) == sizeof( VkStridedBufferRegionKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<StridedBufferRegionKHR>::value, "struct wrapper is not a standard layout!" );
@@ -63891,6 +70331,8 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SubmitInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubmitInfo;
+
     VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = {},
                                      const VULKAN_HPP_NAMESPACE::Semaphore* pWaitSemaphores_ = {},
                                      const VULKAN_HPP_NAMESPACE::PipelineStageFlags* pWaitDstStageMask_ = {},
@@ -63972,6 +70414,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSubmitInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubmitInfo*>( this );
@@ -63982,6 +70425,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubmitInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SubmitInfo const& ) const = default;
 #else
@@ -64004,6 +70448,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubmitInfo;
     const void* pNext = {};
@@ -64014,12 +70460,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::CommandBuffer* pCommandBuffers = {};
     uint32_t signalSemaphoreCount = {};
     const VULKAN_HPP_NAMESPACE::Semaphore* pSignalSemaphores = {};
+
   };
   static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SubmitInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSubmitInfo>
+  {
+    using Type = SubmitInfo;
+  };
+
   struct SubpassBeginInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassBeginInfo;
+
     VULKAN_HPP_CONSTEXPR SubpassBeginInfo( VULKAN_HPP_NAMESPACE::SubpassContents contents_ = VULKAN_HPP_NAMESPACE::SubpassContents::eInline ) VULKAN_HPP_NOEXCEPT
       : contents( contents_ )
     {}
@@ -64053,6 +70508,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSubpassBeginInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassBeginInfo*>( this );
@@ -64063,6 +70519,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassBeginInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SubpassBeginInfo const& ) const = default;
 #else
@@ -64079,16 +70536,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassBeginInfo;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::SubpassContents contents = VULKAN_HPP_NAMESPACE::SubpassContents::eInline;
+
   };
   static_assert( sizeof( SubpassBeginInfo ) == sizeof( VkSubpassBeginInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SubpassBeginInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSubpassBeginInfo>
+  {
+    using Type = SubpassBeginInfo;
+  };
+
   struct SubpassDescriptionDepthStencilResolve
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDescriptionDepthStencilResolve;
+
     VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolve( VULKAN_HPP_NAMESPACE::ResolveModeFlagBits depthResolveMode_ = VULKAN_HPP_NAMESPACE::ResolveModeFlagBits::eNone,
                                                                 VULKAN_HPP_NAMESPACE::ResolveModeFlagBits stencilResolveMode_ = VULKAN_HPP_NAMESPACE::ResolveModeFlagBits::eNone,
                                                                 const VULKAN_HPP_NAMESPACE::AttachmentReference2* pDepthStencilResolveAttachment_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -64138,6 +70606,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSubpassDescriptionDepthStencilResolve const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>( this );
@@ -64148,6 +70617,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SubpassDescriptionDepthStencilResolve const& ) const = default;
 #else
@@ -64166,18 +70636,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolve;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ResolveModeFlagBits depthResolveMode = VULKAN_HPP_NAMESPACE::ResolveModeFlagBits::eNone;
     VULKAN_HPP_NAMESPACE::ResolveModeFlagBits stencilResolveMode = VULKAN_HPP_NAMESPACE::ResolveModeFlagBits::eNone;
     const VULKAN_HPP_NAMESPACE::AttachmentReference2* pDepthStencilResolveAttachment = {};
+
   };
   static_assert( sizeof( SubpassDescriptionDepthStencilResolve ) == sizeof( VkSubpassDescriptionDepthStencilResolve ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SubpassDescriptionDepthStencilResolve>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSubpassDescriptionDepthStencilResolve>
+  {
+    using Type = SubpassDescriptionDepthStencilResolve;
+  };
+
   struct SubpassEndInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassEndInfo;
+
     VULKAN_HPP_CONSTEXPR SubpassEndInfo() VULKAN_HPP_NOEXCEPT
     {}
 
@@ -64204,6 +70685,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSubpassEndInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSubpassEndInfo*>( this );
@@ -64214,6 +70696,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassEndInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SubpassEndInfo const& ) const = default;
 #else
@@ -64229,15 +70712,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassEndInfo;
     const void* pNext = {};
+
   };
   static_assert( sizeof( SubpassEndInfo ) == sizeof( VkSubpassEndInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SubpassEndInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSubpassEndInfo>
+  {
+    using Type = SubpassEndInfo;
+  };
+
   struct SurfaceCapabilities2EXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilities2EXT;
+
     VULKAN_HPP_CONSTEXPR SurfaceCapabilities2EXT( uint32_t minImageCount_ = {},
                                                   uint32_t maxImageCount_ = {},
                                                   VULKAN_HPP_NAMESPACE::Extent2D currentExtent_ = {},
@@ -64279,6 +70773,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSurfaceCapabilities2EXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>( this );
@@ -64289,6 +70784,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceCapabilities2EXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SurfaceCapabilities2EXT const& ) const = default;
 #else
@@ -64315,6 +70811,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceCapabilities2EXT;
     void* pNext = {};
@@ -64329,12 +70827,20 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR supportedCompositeAlpha = {};
     VULKAN_HPP_NAMESPACE::ImageUsageFlags supportedUsageFlags = {};
     VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT supportedSurfaceCounters = {};
+
   };
   static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceCapabilities2EXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSurfaceCapabilities2EXT>
+  {
+    using Type = SurfaceCapabilities2EXT;
+  };
+
   struct SurfaceCapabilitiesKHR
   {
+
     VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesKHR( uint32_t minImageCount_ = {},
                                                  uint32_t maxImageCount_ = {},
                                                  VULKAN_HPP_NAMESPACE::Extent2D currentExtent_ = {},
@@ -64368,6 +70874,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSurfaceCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>( this );
@@ -64378,6 +70885,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceCapabilitiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SurfaceCapabilitiesKHR const& ) const = default;
 #else
@@ -64401,6 +70909,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t minImageCount = {};
     uint32_t maxImageCount = {};
@@ -64412,12 +70922,15 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR currentTransform = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity;
     VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR supportedCompositeAlpha = {};
     VULKAN_HPP_NAMESPACE::ImageUsageFlags supportedUsageFlags = {};
+
   };
   static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct SurfaceCapabilities2KHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilities2KHR;
+
     VULKAN_HPP_CONSTEXPR SurfaceCapabilities2KHR( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities_ = {} ) VULKAN_HPP_NOEXCEPT
       : surfaceCapabilities( surfaceCapabilities_ )
     {}
@@ -64439,6 +70952,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSurfaceCapabilities2KHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>( this );
@@ -64449,6 +70963,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceCapabilities2KHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SurfaceCapabilities2KHR const& ) const = default;
 #else
@@ -64465,17 +70980,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceCapabilities2KHR;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities = {};
+
   };
   static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceCapabilities2KHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSurfaceCapabilities2KHR>
+  {
+    using Type = SurfaceCapabilities2KHR;
+  };
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct SurfaceCapabilitiesFullScreenExclusiveEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT;
+
     VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( VULKAN_HPP_NAMESPACE::Bool32 fullScreenExclusiveSupported_ = {} ) VULKAN_HPP_NOEXCEPT
       : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ )
     {}
@@ -64509,6 +71035,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>( this );
@@ -64519,6 +71046,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SurfaceCapabilitiesFullScreenExclusiveEXT const& ) const = default;
 #else
@@ -64535,17 +71063,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 fullScreenExclusiveSupported = {};
+
   };
   static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceCapabilitiesFullScreenExclusiveEXT>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT>
+  {
+    using Type = SurfaceCapabilitiesFullScreenExclusiveEXT;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct SurfaceFormatKHR
   {
+
     VULKAN_HPP_CONSTEXPR SurfaceFormatKHR( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
                                            VULKAN_HPP_NAMESPACE::ColorSpaceKHR colorSpace_ = VULKAN_HPP_NAMESPACE::ColorSpaceKHR::eSrgbNonlinear ) VULKAN_HPP_NOEXCEPT
       : format( format_ )
@@ -64563,6 +71101,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSurfaceFormatKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceFormatKHR*>( this );
@@ -64573,6 +71112,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceFormatKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SurfaceFormatKHR const& ) const = default;
 #else
@@ -64588,15 +71128,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     VULKAN_HPP_NAMESPACE::Format format = VULKAN_HPP_NAMESPACE::Format::eUndefined;
     VULKAN_HPP_NAMESPACE::ColorSpaceKHR colorSpace = VULKAN_HPP_NAMESPACE::ColorSpaceKHR::eSrgbNonlinear;
+
   };
   static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceFormatKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct SurfaceFormat2KHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFormat2KHR;
+
     VULKAN_HPP_CONSTEXPR SurfaceFormat2KHR( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR surfaceFormat_ = {} ) VULKAN_HPP_NOEXCEPT
       : surfaceFormat( surfaceFormat_ )
     {}
@@ -64618,6 +71163,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSurfaceFormat2KHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceFormat2KHR*>( this );
@@ -64628,6 +71174,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceFormat2KHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SurfaceFormat2KHR const& ) const = default;
 #else
@@ -64644,17 +71191,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceFormat2KHR;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::SurfaceFormatKHR surfaceFormat = {};
+
   };
   static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceFormat2KHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSurfaceFormat2KHR>
+  {
+    using Type = SurfaceFormat2KHR;
+  };
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct SurfaceFullScreenExclusiveInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFullScreenExclusiveInfoEXT;
+
     VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT fullScreenExclusive_ = VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT::eDefault ) VULKAN_HPP_NOEXCEPT
       : fullScreenExclusive( fullScreenExclusive_ )
     {}
@@ -64688,6 +71246,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSurfaceFullScreenExclusiveInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>( this );
@@ -64698,6 +71257,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SurfaceFullScreenExclusiveInfoEXT const& ) const = default;
 #else
@@ -64714,18 +71274,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT fullScreenExclusive = VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT::eDefault;
+
   };
   static_assert( sizeof( SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceFullScreenExclusiveInfoEXT>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eSurfaceFullScreenExclusiveInfoEXT>
+  {
+    using Type = SurfaceFullScreenExclusiveInfoEXT;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct SurfaceFullScreenExclusiveWin32InfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT;
+
     VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = {} ) VULKAN_HPP_NOEXCEPT
       : hmonitor( hmonitor_ )
     {}
@@ -64759,6 +71330,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSurfaceFullScreenExclusiveWin32InfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>( this );
@@ -64769,6 +71341,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SurfaceFullScreenExclusiveWin32InfoEXT const& ) const = default;
 #else
@@ -64785,17 +71358,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT;
     const void* pNext = {};
     HMONITOR hmonitor = {};
+
   };
   static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceFullScreenExclusiveWin32InfoEXT>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT>
+  {
+    using Type = SurfaceFullScreenExclusiveWin32InfoEXT;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct SurfaceProtectedCapabilitiesKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceProtectedCapabilitiesKHR;
+
     VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( VULKAN_HPP_NAMESPACE::Bool32 supportsProtected_ = {} ) VULKAN_HPP_NOEXCEPT
       : supportsProtected( supportsProtected_ )
     {}
@@ -64829,6 +71413,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSurfaceProtectedCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>( this );
@@ -64839,6 +71424,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SurfaceProtectedCapabilitiesKHR const& ) const = default;
 #else
@@ -64855,16 +71441,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 supportsProtected = {};
+
   };
   static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceProtectedCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSurfaceProtectedCapabilitiesKHR>
+  {
+    using Type = SurfaceProtectedCapabilitiesKHR;
+  };
+
   struct SwapchainCounterCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCounterCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT surfaceCounters_ = {} ) VULKAN_HPP_NOEXCEPT
       : surfaceCounters( surfaceCounters_ )
     {}
@@ -64898,6 +71495,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSwapchainCounterCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>( this );
@@ -64908,6 +71506,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SwapchainCounterCreateInfoEXT const& ) const = default;
 #else
@@ -64924,16 +71523,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT surfaceCounters = {};
+
   };
   static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SwapchainCounterCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSwapchainCounterCreateInfoEXT>
+  {
+    using Type = SwapchainCounterCreateInfoEXT;
+  };
+
   struct SwapchainCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR flags_ = {},
                                                  VULKAN_HPP_NAMESPACE::SurfaceKHR surface_ = {},
                                                  uint32_t minImageCount_ = {},
@@ -65021,7 +71631,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setImageExtent( VULKAN_HPP_NAMESPACE::Extent2D imageExtent_ ) VULKAN_HPP_NOEXCEPT
+    SwapchainCreateInfoKHR & setImageExtent( VULKAN_HPP_NAMESPACE::Extent2D const & imageExtent_ ) VULKAN_HPP_NOEXCEPT
     {
       imageExtent = imageExtent_;
       return *this;
@@ -65087,6 +71697,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSwapchainCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>( this );
@@ -65097,6 +71708,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSwapchainCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SwapchainCreateInfoKHR const& ) const = default;
 #else
@@ -65128,6 +71740,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSwapchainCreateInfoKHR;
     const void* pNext = {};
@@ -65147,12 +71761,21 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::PresentModeKHR presentMode = VULKAN_HPP_NAMESPACE::PresentModeKHR::eImmediate;
     VULKAN_HPP_NAMESPACE::Bool32 clipped = {};
     VULKAN_HPP_NAMESPACE::SwapchainKHR oldSwapchain = {};
+
   };
   static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSwapchainCreateInfoKHR>
+  {
+    using Type = SwapchainCreateInfoKHR;
+  };
+
   struct SwapchainDisplayNativeHdrCreateInfoAMD
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD;
+
     VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable_ = {} ) VULKAN_HPP_NOEXCEPT
       : localDimmingEnable( localDimmingEnable_ )
     {}
@@ -65186,6 +71809,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkSwapchainDisplayNativeHdrCreateInfoAMD const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>( this );
@@ -65196,6 +71820,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( SwapchainDisplayNativeHdrCreateInfoAMD const& ) const = default;
 #else
@@ -65212,16 +71837,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable = {};
+
   };
   static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SwapchainDisplayNativeHdrCreateInfoAMD>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD>
+  {
+    using Type = SwapchainDisplayNativeHdrCreateInfoAMD;
+  };
+
   struct TextureLODGatherFormatPropertiesAMD
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTextureLodGatherFormatPropertiesAMD;
+
     VULKAN_HPP_CONSTEXPR TextureLODGatherFormatPropertiesAMD( VULKAN_HPP_NAMESPACE::Bool32 supportsTextureGatherLODBiasAMD_ = {} ) VULKAN_HPP_NOEXCEPT
       : supportsTextureGatherLODBiasAMD( supportsTextureGatherLODBiasAMD_ )
     {}
@@ -65243,6 +71879,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkTextureLODGatherFormatPropertiesAMD const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>( this );
@@ -65253,6 +71890,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( TextureLODGatherFormatPropertiesAMD const& ) const = default;
 #else
@@ -65269,16 +71907,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD;
     void* pNext = {};
     VULKAN_HPP_NAMESPACE::Bool32 supportsTextureGatherLODBiasAMD = {};
+
   };
   static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<TextureLODGatherFormatPropertiesAMD>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eTextureLodGatherFormatPropertiesAMD>
+  {
+    using Type = TextureLODGatherFormatPropertiesAMD;
+  };
+
   struct TimelineSemaphoreSubmitInfo
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTimelineSemaphoreSubmitInfo;
+
     VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfo( uint32_t waitSemaphoreValueCount_ = {},
                                                       const uint64_t* pWaitSemaphoreValues_ = {},
                                                       uint32_t signalSemaphoreValueCount_ = {},
@@ -65336,6 +71985,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkTimelineSemaphoreSubmitInfo const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>( this );
@@ -65346,6 +71996,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( TimelineSemaphoreSubmitInfo const& ) const = default;
 #else
@@ -65365,6 +72016,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eTimelineSemaphoreSubmitInfo;
     const void* pNext = {};
@@ -65372,13 +72025,21 @@ namespace VULKAN_HPP_NAMESPACE
     const uint64_t* pWaitSemaphoreValues = {};
     uint32_t signalSemaphoreValueCount = {};
     const uint64_t* pSignalSemaphoreValues = {};
+
   };
   static_assert( sizeof( TimelineSemaphoreSubmitInfo ) == sizeof( VkTimelineSemaphoreSubmitInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<TimelineSemaphoreSubmitInfo>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eTimelineSemaphoreSubmitInfo>
+  {
+    using Type = TimelineSemaphoreSubmitInfo;
+  };
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   struct TraceRaysIndirectCommandKHR
   {
+
     VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommandKHR( uint32_t width_ = {},
                                                       uint32_t height_ = {},
                                                       uint32_t depth_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -65423,6 +72084,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkTraceRaysIndirectCommandKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkTraceRaysIndirectCommandKHR*>( this );
@@ -65433,6 +72095,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkTraceRaysIndirectCommandKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( TraceRaysIndirectCommandKHR const& ) const = default;
 #else
@@ -65449,10 +72112,13 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     uint32_t width = {};
     uint32_t height = {};
     uint32_t depth = {};
+
   };
   static_assert( sizeof( TraceRaysIndirectCommandKHR ) == sizeof( VkTraceRaysIndirectCommandKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<TraceRaysIndirectCommandKHR>::value, "struct wrapper is not a standard layout!" );
@@ -65460,6 +72126,8 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ValidationCacheCreateInfoEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationCacheCreateInfoEXT;
+
     VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT flags_ = {},
                                                        size_t initialDataSize_ = {},
                                                        const void* pInitialData_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -65509,6 +72177,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkValidationCacheCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( this );
@@ -65519,6 +72188,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkValidationCacheCreateInfoEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ValidationCacheCreateInfoEXT const& ) const = default;
 #else
@@ -65537,18 +72207,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eValidationCacheCreateInfoEXT;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT flags = {};
     size_t initialDataSize = {};
     const void* pInitialData = {};
+
   };
   static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ValidationCacheCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eValidationCacheCreateInfoEXT>
+  {
+    using Type = ValidationCacheCreateInfoEXT;
+  };
+
   struct ValidationFeaturesEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationFeaturesEXT;
+
     VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = {},
                                                 const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = {},
                                                 uint32_t disabledValidationFeatureCount_ = {},
@@ -65606,6 +72287,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkValidationFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkValidationFeaturesEXT*>( this );
@@ -65616,6 +72298,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkValidationFeaturesEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ValidationFeaturesEXT const& ) const = default;
 #else
@@ -65635,6 +72318,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eValidationFeaturesEXT;
     const void* pNext = {};
@@ -65642,12 +72327,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT* pEnabledValidationFeatures = {};
     uint32_t disabledValidationFeatureCount = {};
     const VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT* pDisabledValidationFeatures = {};
+
   };
   static_assert( sizeof( ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ValidationFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eValidationFeaturesEXT>
+  {
+    using Type = ValidationFeaturesEXT;
+  };
+
   struct ValidationFlagsEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationFlagsEXT;
+
     VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = {},
                                              const VULKAN_HPP_NAMESPACE::ValidationCheckEXT* pDisabledValidationChecks_ = {} ) VULKAN_HPP_NOEXCEPT
       : disabledValidationCheckCount( disabledValidationCheckCount_ )
@@ -65689,6 +72383,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkValidationFlagsEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkValidationFlagsEXT*>( this );
@@ -65699,6 +72394,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkValidationFlagsEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ValidationFlagsEXT const& ) const = default;
 #else
@@ -65716,18 +72412,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eValidationFlagsEXT;
     const void* pNext = {};
     uint32_t disabledValidationCheckCount = {};
     const VULKAN_HPP_NAMESPACE::ValidationCheckEXT* pDisabledValidationChecks = {};
+
   };
   static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ValidationFlagsEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eValidationFlagsEXT>
+  {
+    using Type = ValidationFlagsEXT;
+  };
+
 #ifdef VK_USE_PLATFORM_VI_NN
   struct ViSurfaceCreateInfoNN
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eViSurfaceCreateInfoNN;
+
     VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN flags_ = {},
                                                 void* window_ = {} ) VULKAN_HPP_NOEXCEPT
       : flags( flags_ )
@@ -65769,6 +72476,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkViSurfaceCreateInfoNN const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkViSurfaceCreateInfoNN*>( this );
@@ -65779,6 +72487,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkViSurfaceCreateInfoNN*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( ViSurfaceCreateInfoNN const& ) const = default;
 #else
@@ -65796,19 +72505,30 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eViSurfaceCreateInfoNN;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN flags = {};
     void* window = {};
+
   };
   static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ViSurfaceCreateInfoNN>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eViSurfaceCreateInfoNN>
+  {
+    using Type = ViSurfaceCreateInfoNN;
+  };
 #endif /*VK_USE_PLATFORM_VI_NN*/
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
   struct WaylandSurfaceCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWaylandSurfaceCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR flags_ = {},
                                                       struct wl_display* display_ = {},
                                                       struct wl_surface* surface_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -65858,6 +72578,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkWaylandSurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( this );
@@ -65868,6 +72589,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( WaylandSurfaceCreateInfoKHR const& ) const = default;
 #else
@@ -65886,20 +72608,31 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR flags = {};
     struct wl_display* display = {};
     struct wl_surface* surface = {};
+
   };
   static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<WaylandSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eWaylandSurfaceCreateInfoKHR>
+  {
+    using Type = WaylandSurfaceCreateInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct Win32KeyedMutexAcquireReleaseInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR;
+
     VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = {},
                                                                const VULKAN_HPP_NAMESPACE::DeviceMemory* pAcquireSyncs_ = {},
                                                                const uint64_t* pAcquireKeys_ = {},
@@ -65981,6 +72714,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkWin32KeyedMutexAcquireReleaseInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>( this );
@@ -65991,6 +72725,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( Win32KeyedMutexAcquireReleaseInfoKHR const& ) const = default;
 #else
@@ -66013,6 +72748,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR;
     const void* pNext = {};
@@ -66023,14 +72760,23 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t releaseCount = {};
     const VULKAN_HPP_NAMESPACE::DeviceMemory* pReleaseSyncs = {};
     const uint64_t* pReleaseKeys = {};
+
   };
   static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Win32KeyedMutexAcquireReleaseInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR>
+  {
+    using Type = Win32KeyedMutexAcquireReleaseInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct Win32KeyedMutexAcquireReleaseInfoNV
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV;
+
     VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = {},
                                                               const VULKAN_HPP_NAMESPACE::DeviceMemory* pAcquireSyncs_ = {},
                                                               const uint64_t* pAcquireKeys_ = {},
@@ -66112,6 +72858,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkWin32KeyedMutexAcquireReleaseInfoNV const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>( this );
@@ -66122,6 +72869,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( Win32KeyedMutexAcquireReleaseInfoNV const& ) const = default;
 #else
@@ -66144,6 +72892,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV;
     const void* pNext = {};
@@ -66154,14 +72904,23 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t releaseCount = {};
     const VULKAN_HPP_NAMESPACE::DeviceMemory* pReleaseSyncs = {};
     const uint64_t* pReleaseKeys = {};
+
   };
   static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Win32KeyedMutexAcquireReleaseInfoNV>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eWin32KeyedMutexAcquireReleaseInfoNV>
+  {
+    using Type = Win32KeyedMutexAcquireReleaseInfoNV;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct Win32SurfaceCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32SurfaceCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR flags_ = {},
                                                     HINSTANCE hinstance_ = {},
                                                     HWND hwnd_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -66211,6 +72970,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkWin32SurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( this );
@@ -66221,6 +72981,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( Win32SurfaceCreateInfoKHR const& ) const = default;
 #else
@@ -66239,19 +73000,30 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR flags = {};
     HINSTANCE hinstance = {};
     HWND hwnd = {};
+
   };
   static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Win32SurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eWin32SurfaceCreateInfoKHR>
+  {
+    using Type = Win32SurfaceCreateInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct WriteDescriptorSet
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSet;
+
     VULKAN_HPP_CONSTEXPR WriteDescriptorSet( VULKAN_HPP_NAMESPACE::DescriptorSet dstSet_ = {},
                                              uint32_t dstBinding_ = {},
                                              uint32_t dstArrayElement_ = {},
@@ -66341,6 +73113,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkWriteDescriptorSet const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWriteDescriptorSet*>( this );
@@ -66351,6 +73124,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWriteDescriptorSet*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( WriteDescriptorSet const& ) const = default;
 #else
@@ -66374,6 +73148,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWriteDescriptorSet;
     const void* pNext = {};
@@ -66385,12 +73161,21 @@ namespace VULKAN_HPP_NAMESPACE
     const VULKAN_HPP_NAMESPACE::DescriptorImageInfo* pImageInfo = {};
     const VULKAN_HPP_NAMESPACE::DescriptorBufferInfo* pBufferInfo = {};
     const VULKAN_HPP_NAMESPACE::BufferView* pTexelBufferView = {};
+
   };
   static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<WriteDescriptorSet>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eWriteDescriptorSet>
+  {
+    using Type = WriteDescriptorSet;
+  };
+
   struct WriteDescriptorSetAccelerationStructureKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetAccelerationStructureKHR;
+
     VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureKHR( uint32_t accelerationStructureCount_ = {},
                                                                      const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR* pAccelerationStructures_ = {} ) VULKAN_HPP_NOEXCEPT
       : accelerationStructureCount( accelerationStructureCount_ )
@@ -66432,6 +73217,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkWriteDescriptorSetAccelerationStructureKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>( this );
@@ -66442,6 +73228,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( WriteDescriptorSetAccelerationStructureKHR const& ) const = default;
 #else
@@ -66459,17 +73246,28 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureKHR;
     const void* pNext = {};
     uint32_t accelerationStructureCount = {};
     const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR* pAccelerationStructures = {};
+
   };
   static_assert( sizeof( WriteDescriptorSetAccelerationStructureKHR ) == sizeof( VkWriteDescriptorSetAccelerationStructureKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<WriteDescriptorSetAccelerationStructureKHR>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eWriteDescriptorSetAccelerationStructureKHR>
+  {
+    using Type = WriteDescriptorSetAccelerationStructureKHR;
+  };
+
   struct WriteDescriptorSetInlineUniformBlockEXT
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT;
+
     VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = {},
                                                                   const void* pData_ = {} ) VULKAN_HPP_NOEXCEPT
       : dataSize( dataSize_ )
@@ -66511,6 +73309,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkWriteDescriptorSetInlineUniformBlockEXT const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>( this );
@@ -66521,6 +73320,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( WriteDescriptorSetInlineUniformBlockEXT const& ) const = default;
 #else
@@ -66538,18 +73338,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT;
     const void* pNext = {};
     uint32_t dataSize = {};
     const void* pData = {};
+
   };
   static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<WriteDescriptorSetInlineUniformBlockEXT>::value, "struct wrapper is not a standard layout!" );
 
+  template <>
+  struct CppType<StructureType, StructureType::eWriteDescriptorSetInlineUniformBlockEXT>
+  {
+    using Type = WriteDescriptorSetInlineUniformBlockEXT;
+  };
+
 #ifdef VK_USE_PLATFORM_XCB_KHR
   struct XcbSurfaceCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eXcbSurfaceCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR flags_ = {},
                                                   xcb_connection_t* connection_ = {},
                                                   xcb_window_t window_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -66599,6 +73410,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkXcbSurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( this );
@@ -66609,6 +73421,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( XcbSurfaceCreateInfoKHR const& ) const = default;
 #else
@@ -66627,20 +73440,31 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR flags = {};
     xcb_connection_t* connection = {};
     xcb_window_t window = {};
+
   };
   static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<XcbSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eXcbSurfaceCreateInfoKHR>
+  {
+    using Type = XcbSurfaceCreateInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
   struct XlibSurfaceCreateInfoKHR
   {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eXlibSurfaceCreateInfoKHR;
+
     VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR flags_ = {},
                                                    Display* dpy_ = {},
                                                    Window window_ = {} ) VULKAN_HPP_NOEXCEPT
@@ -66690,6 +73514,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+
     operator VkXlibSurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( this );
@@ -66700,6 +73525,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>( this );
     }
 
+
 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
     auto operator<=>( XlibSurfaceCreateInfoKHR const& ) const = default;
 #else
@@ -66718,15 +73544,24 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+
+
   public:
     const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR;
     const void* pNext = {};
     VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR flags = {};
     Display* dpy = {};
     Window window = {};
+
   };
   static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<XlibSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eXlibSurfaceCreateInfoKHR>
+  {
+    using Type = XlibSurfaceCreateInfoKHR;
+  };
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
   template<typename Dispatch>
@@ -75941,6 +82776,9 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceRayTracingPropertiesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceRobustness2FeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceRobustness2FeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceRobustness2PropertiesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSampleLocationsPropertiesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSamplerFilterMinmaxProperties>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceSamplerYcbcrConversionFeatures>{ enum { value = true }; };
@@ -76171,6 +83009,7 @@ namespace VULKAN_HPP_NAMESPACE
   };
 #endif
 
+
   class DispatchLoaderDynamic
   {
   public:
@@ -77681,6 +84520,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 namespace std
 {
+
   template <> struct hash<vk::AccelerationStructureKHR>
   {
     std::size_t operator()(vk::AccelerationStructureKHR const& accelerationStructureKHR) const VULKAN_HPP_NOEXCEPT
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index 51c9376..6187c6d 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -44,7 +44,7 @@ extern "C" {
 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
 // Version of this file
-#define VK_HEADER_VERSION 137
+#define VK_HEADER_VERSION 139
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_VERSION(1, 2, VK_HEADER_VERSION)
@@ -594,6 +594,8 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000,
     VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001,
     VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = 1000297000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000,
@@ -1955,6 +1957,8 @@ typedef VkFlags VkAttachmentDescriptionFlags;
 typedef enum VkSubpassDescriptionFlagBits {
     VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
     VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
+    VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004,
+    VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008,
     VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkSubpassDescriptionFlagBits;
 typedef VkFlags VkSubpassDescriptionFlags;
@@ -9596,6 +9600,11 @@ typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT {
 
 
 
+#define VK_QCOM_render_pass_shader_resolve 1
+#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION 4
+#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME "VK_QCOM_render_pass_shader_resolve"
+
+
 #define VK_EXT_global_priority 1
 #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2
 #define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"
@@ -10909,6 +10918,26 @@ typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM {
 
 
 
+#define VK_EXT_robustness2 1
+#define VK_EXT_ROBUSTNESS_2_SPEC_VERSION  1
+#define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2"
+typedef struct VkPhysicalDeviceRobustness2FeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           robustBufferAccess2;
+    VkBool32           robustImageAccess2;
+    VkBool32           nullDescriptor;
+} VkPhysicalDeviceRobustness2FeaturesEXT;
+
+typedef struct VkPhysicalDeviceRobustness2PropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       robustStorageBufferAccessSizeAlignment;
+    VkDeviceSize       robustUniformBufferAccessSizeAlignment;
+} VkPhysicalDeviceRobustness2PropertiesEXT;
+
+
+
 #define VK_GOOGLE_user_type 1
 #define VK_GOOGLE_USER_TYPE_SPEC_VERSION  1
 #define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type"
diff --git a/registry/generator.py b/registry/generator.py
index 95fda21..bbddbd5 100644
--- a/registry/generator.py
+++ b/registry/generator.py
@@ -564,7 +564,7 @@ class OutputGenerator:
 
         # Open a temporary file for accumulating output.
         if self.genOpts.filename is not None:
-            self.outFile = tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', delete=False)
+            self.outFile = tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', newline='\n', delete=False)
         else:
             self.outFile = sys.stdout
 
diff --git a/registry/validusage.json b/registry/validusage.json
index b2c58c7..654d628 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.2.137",
-    "comment": "from git branch: github-master commit: 019f62b11de9358d3383ead2e1a8c5bc2fda23ad",
-    "date": "2020-04-07 05:14:56Z"
+    "api version": "1.2.139",
+    "comment": "from git branch: github-master commit: 5789d98a3fb3e02beb2f92aab5dd4b87d648cfc2",
+    "date": "2020-04-26 21:27:12Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -222,7 +222,7 @@
         },
         {
           "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixPropertiesNV\">VkPhysicalDeviceCooperativeMatrixPropertiesNV</a>, <a href=\"#VkPhysicalDeviceDepthStencilResolveProperties\">VkPhysicalDeviceDepthStencilResolveProperties</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingProperties\">VkPhysicalDeviceDescriptorIndexingProperties</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV\">VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDriverProperties\">VkPhysicalDeviceDriverProperties</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsProperties\">VkPhysicalDeviceFloatControlsProperties</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapPropertiesEXT\">VkPhysicalDeviceFragmentDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockPropertiesEXT\">VkPhysicalDeviceInlineUniformBlockPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationPropertiesEXT\">VkPhysicalDeviceLineRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesNV\">VkPhysicalDeviceMeshShaderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDevicePCIBusInfoPropertiesEXT\">VkPhysicalDevicePCIBusInfoPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePerformanceQueryPropertiesKHR\">VkPhysicalDevicePerformanceQueryPropertiesKHR</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesKHR\">VkPhysicalDeviceRayTracingPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxProperties\">VkPhysicalDeviceSamplerFilterMinmaxProperties</a>, <a href=\"#VkPhysicalDeviceShaderCoreProperties2AMD\">VkPhysicalDeviceShaderCoreProperties2AMD</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsPropertiesNV\">VkPhysicalDeviceShaderSMBuiltinsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceShadingRateImagePropertiesNV\">VkPhysicalDeviceShadingRateImagePropertiesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlPropertiesEXT\">VkPhysicalDeviceSubgroupSizeControlPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreProperties\">VkPhysicalDeviceTimelineSemaphoreProperties</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Properties\">VkPhysicalDeviceVulkan11Properties</a>, or <a href=\"#VkPhysicalDeviceVulkan12Properties\">VkPhysicalDeviceVulkan12Properties</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixPropertiesNV\">VkPhysicalDeviceCooperativeMatrixPropertiesNV</a>, <a href=\"#VkPhysicalDeviceDepthStencilResolveProperties\">VkPhysicalDeviceDepthStencilResolveProperties</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingProperties\">VkPhysicalDeviceDescriptorIndexingProperties</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV\">VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDriverProperties\">VkPhysicalDeviceDriverProperties</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsProperties\">VkPhysicalDeviceFloatControlsProperties</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapPropertiesEXT\">VkPhysicalDeviceFragmentDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockPropertiesEXT\">VkPhysicalDeviceInlineUniformBlockPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationPropertiesEXT\">VkPhysicalDeviceLineRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesNV\">VkPhysicalDeviceMeshShaderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDevicePCIBusInfoPropertiesEXT\">VkPhysicalDevicePCIBusInfoPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePerformanceQueryPropertiesKHR\">VkPhysicalDevicePerformanceQueryPropertiesKHR</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesKHR\">VkPhysicalDeviceRayTracingPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2PropertiesEXT\">VkPhysicalDeviceRobustness2PropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxProperties\">VkPhysicalDeviceSamplerFilterMinmaxProperties</a>, <a href=\"#VkPhysicalDeviceShaderCoreProperties2AMD\">VkPhysicalDeviceShaderCoreProperties2AMD</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsPropertiesNV\">VkPhysicalDeviceShaderSMBuiltinsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceShadingRateImagePropertiesNV\">VkPhysicalDeviceShadingRateImagePropertiesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlPropertiesEXT\">VkPhysicalDeviceSubgroupSizeControlPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreProperties\">VkPhysicalDeviceTimelineSemaphoreProperties</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Properties\">VkPhysicalDeviceVulkan11Properties</a>, or <a href=\"#VkPhysicalDeviceVulkan12Properties\">VkPhysicalDeviceVulkan12Properties</a>"
         },
         {
           "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique",
@@ -506,7 +506,7 @@
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceDiagnosticsConfigCreateInfoNV\">VkDeviceDiagnosticsConfigCreateInfoNV</a>, <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice8BitStorageFeatures\">VkPhysicalDevice8BitStorageFeatures</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeatures\">VkPhysicalDeviceBufferDeviceAddressFeatures</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\">VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCoherentMemoryFeaturesAMD\">VkPhysicalDeviceCoherentMemoryFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesNV\">VkPhysicalDeviceCooperativeMatrixFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCoverageReductionModeFeaturesNV\">VkPhysicalDeviceCoverageReductionModeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV\">VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDepthClipEnableFeaturesEXT\">VkPhysicalDeviceDepthClipEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeatures\">VkPhysicalDeviceDescriptorIndexingFeatures</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDiagnosticsConfigFeaturesNV\">VkPhysicalDeviceDiagnosticsConfigFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\">VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceHostQueryResetFeatures\">VkPhysicalDeviceHostQueryResetFeatures</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeatures\">VkPhysicalDeviceImagelessFramebufferFeatures</a>, <a href=\"#VkPhysicalDeviceIndexTypeUint8FeaturesEXT\">VkPhysicalDeviceIndexTypeUint8FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationFeaturesEXT\">VkPhysicalDeviceLineRasterizationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDevicePerformanceQueryFeaturesKHR\">VkPhysicalDevicePerformanceQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT\">VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\">VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceRayTracingFeaturesKHR\">VkPhysicalDeviceRayTracingFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeatures\">VkPhysicalDeviceScalarBlockLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64Features\">VkPhysicalDeviceShaderAtomicInt64Features</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderFloat16Int8Features\">VkPhysicalDeviceShaderFloat16Int8Features</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\">VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeaturesEXT\">VkPhysicalDeviceSubgroupSizeControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT\">VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeatures\">VkPhysicalDeviceTimelineSemaphoreFeatures</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeatures\">VkPhysicalDeviceUniformBufferStandardLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a>, <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeatures\">VkPhysicalDeviceVulkanMemoryModelFeatures</a>, or <a href=\"#VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\">VkPhysicalDeviceYcbcrImageArraysFeaturesEXT</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceDiagnosticsConfigCreateInfoNV\">VkDeviceDiagnosticsConfigCreateInfoNV</a>, <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice8BitStorageFeatures\">VkPhysicalDevice8BitStorageFeatures</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeatures\">VkPhysicalDeviceBufferDeviceAddressFeatures</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\">VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCoherentMemoryFeaturesAMD\">VkPhysicalDeviceCoherentMemoryFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesNV\">VkPhysicalDeviceCooperativeMatrixFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCoverageReductionModeFeaturesNV\">VkPhysicalDeviceCoverageReductionModeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV\">VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDepthClipEnableFeaturesEXT\">VkPhysicalDeviceDepthClipEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeatures\">VkPhysicalDeviceDescriptorIndexingFeatures</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDiagnosticsConfigFeaturesNV\">VkPhysicalDeviceDiagnosticsConfigFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\">VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceHostQueryResetFeatures\">VkPhysicalDeviceHostQueryResetFeatures</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeatures\">VkPhysicalDeviceImagelessFramebufferFeatures</a>, <a href=\"#VkPhysicalDeviceIndexTypeUint8FeaturesEXT\">VkPhysicalDeviceIndexTypeUint8FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationFeaturesEXT\">VkPhysicalDeviceLineRasterizationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDevicePerformanceQueryFeaturesKHR\">VkPhysicalDevicePerformanceQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT\">VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\">VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceRayTracingFeaturesKHR\">VkPhysicalDeviceRayTracingFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2FeaturesEXT\">VkPhysicalDeviceRobustness2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeatures\">VkPhysicalDeviceScalarBlockLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64Features\">VkPhysicalDeviceShaderAtomicInt64Features</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderFloat16Int8Features\">VkPhysicalDeviceShaderFloat16Int8Features</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\">VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeaturesEXT\">VkPhysicalDeviceSubgroupSizeControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT\">VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeatures\">VkPhysicalDeviceTimelineSemaphoreFeatures</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeatures\">VkPhysicalDeviceUniformBufferStandardLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a>, <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeatures\">VkPhysicalDeviceVulkanMemoryModelFeatures</a>, or <a href=\"#VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\">VkPhysicalDeviceYcbcrImageArraysFeaturesEXT</a>"
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-sType-unique",
@@ -866,11 +866,11 @@
         },
         {
           "vuid": "VUID-vkAllocateCommandBuffers-pCommandBuffers-parameter",
-          "text": " <code>pCommandBuffers</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pAllocateInfo</code>::commandBufferCount <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handles"
+          "text": " <code>pCommandBuffers</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pAllocateInfo-&gt;commandBufferCount</code> <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handles"
         },
         {
           "vuid": "VUID-vkAllocateCommandBuffers-pAllocateInfo::commandBufferCount-arraylength",
-          "text": " The value referenced by <code>pAllocateInfo</code>::<code>commandBufferCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+          "text": " The value referenced by <code>pAllocateInfo-&gt;commandBufferCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
         }
       ]
     },
@@ -1100,7 +1100,7 @@
       "(VK_EXT_conditional_rendering)": [
         {
           "vuid": "VUID-vkEndCommandBuffer-None-01978",
-          "text": " Conditional rendering must not be <a href=\"#active-conditional-rendering\">active</a>"
+          "text": " Conditional rendering <strong class=\"purple\">must</strong> not be <a href=\"#active-conditional-rendering\">active</a>"
         }
       ],
       "(VK_EXT_debug_utils)": [
@@ -1222,7 +1222,7 @@
         },
         {
           "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-00078",
-          "text": " Each element of <code>pWaitDstStageMask</code> <strong class=\"purple\">must</strong> not include <code>VK_PIPELINE_STAGE_HOST_BIT</code>."
+          "text": " Each element of <code>pWaitDstStageMask</code> <strong class=\"purple\">must</strong> not include <code>VK_PIPELINE_STAGE_HOST_BIT</code>"
         },
         {
           "vuid": "VUID-VkSubmitInfo-sType-sType",
@@ -1704,7 +1704,7 @@
       "(VK_VERSION_1_1,VK_KHR_external_fence)": [
         {
           "vuid": "VUID-VkExportFenceCreateInfo-handleTypes-01446",
-          "text": " The bits in <code>handleTypes</code> must be supported and compatible, as reported by <a href=\"#VkExternalFenceProperties\">VkExternalFenceProperties</a>"
+          "text": " The bits in <code>handleTypes</code> <strong class=\"purple\">must</strong> be supported and compatible, as reported by <a href=\"#VkExternalFenceProperties\">VkExternalFenceProperties</a>"
         },
         {
           "vuid": "VUID-VkExportFenceCreateInfo-sType-sType",
@@ -2044,7 +2044,7 @@
         },
         {
           "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handle-01462",
-          "text": " If <code>handle</code> is not <code>NULL</code>, <code>name</code> must be <code>NULL</code>"
+          "text": " If <code>handle</code> is not <code>NULL</code>, <code>name</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
         },
         {
           "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handle-01539",
@@ -2312,7 +2312,7 @@
         },
         {
           "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01136",
-          "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as a POSIX file descriptor handle."
+          "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as a POSIX file descriptor handle"
         },
         {
           "vuid": "VUID-VkSemaphoreGetFdInfoKHR-sType-sType",
@@ -2518,7 +2518,7 @@
         },
         {
           "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469",
-          "text": " If <code>handle</code> is not <code>NULL</code>, <code>name</code> must be <code>NULL</code>"
+          "text": " If <code>handle</code> is not <code>NULL</code>, <code>name</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
         },
         {
           "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01542",
@@ -2530,7 +2530,7 @@
         },
         {
           "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-03261",
-          "text": " If <code>handleType</code> is <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code> or <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT</code>, the <a href=\"#VkSemaphoreCreateInfo\">VkSemaphoreCreateInfo</a>::<code>flags</code> field <strong class=\"purple\">must</strong> match that of the semaphore from which <code>handle</code> or <code>name</code> was exported."
+          "text": " If <code>handleType</code> is <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code> or <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT</code>, the <a href=\"#VkSemaphoreCreateInfo\">VkSemaphoreCreateInfo</a>::<code>flags</code> field <strong class=\"purple\">must</strong> match that of the semaphore from which <code>handle</code> or <code>name</code> was exported"
         },
         {
           "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-sType-sType",
@@ -2592,7 +2592,7 @@
         },
         {
           "vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-03263",
-          "text": " If <code>handleType</code> is <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the <a href=\"#VkSemaphoreCreateInfo\">VkSemaphoreCreateInfo</a>::<code>flags</code> field <strong class=\"purple\">must</strong> match that of the semaphore from which <code>fd</code> was exported."
+          "text": " If <code>handleType</code> is <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the <a href=\"#VkSemaphoreCreateInfo\">VkSemaphoreCreateInfo</a>::<code>flags</code> field <strong class=\"purple\">must</strong> match that of the semaphore from which <code>fd</code> was exported"
         },
         {
           "vuid": "VUID-VkImportSemaphoreFdInfoKHR-sType-sType",
@@ -2918,7 +2918,7 @@
         },
         {
           "vuid": "VUID-vkCmdWaitEvents-srcQueueFamilyIndex-02803",
-          "text": " The <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> members of any element of <code>pBufferMemoryBarriers</code> or <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> be equal."
+          "text": " The <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> members of any element of <code>pBufferMemoryBarriers</code> or <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> be equal"
         },
         {
           "vuid": "VUID-vkCmdWaitEvents-srcAccessMask-02809",
@@ -3526,7 +3526,7 @@
         },
         {
           "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-02511",
-          "text": " For any member of <code>pAttachments</code> with a <code>stencilLoadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_CLEAR</code>, the first use of that attachment <strong class=\"purple\">must</strong> not specify a <code>layout</code> equal to <code>VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL</code> or <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL</code>."
+          "text": " For any member of <code>pAttachments</code> with a <code>stencilLoadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_CLEAR</code>, the first use of that attachment <strong class=\"purple\">must</strong> not specify a <code>layout</code> equal to <code>VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL</code> or <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL</code>"
         },
         {
           "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-00837",
@@ -3937,6 +3937,28 @@
           "text": " If <code>flags</code> includes <code>VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX</code>, it <strong class=\"purple\">must</strong> also include <code>VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX</code>"
         }
       ],
+      "(VK_QCOM_render_pass_shader_resolve)": [
+        {
+          "vuid": "VUID-VkSubpassDescription-flags-03341",
+          "text": " If <code>flags</code> includes <code>VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM</code>, and if <code>pResolveAttachments</code> is not <code>NULL</code>, then each resolve attachment <strong class=\"purple\">must</strong> be <code>VK_ATTACHMENT_UNUSED</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDescription-flags-03342",
+          "text": " If <code>flags</code> includes <code>VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM</code>, and if <code>pDepthStencilResolveAttachmentKHR</code> is not <code>NULL</code>, then the depth/stencil resolve attachment <strong class=\"purple\">must</strong> be <code>VK_ATTACHMENT_UNUSED</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDescription-flags-03343",
+          "text": " If <code>flags</code> includes <code>VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM</code>, then the subpass <strong class=\"purple\">must</strong> be the last subpass in a subpass dependency chain"
+        },
+        {
+          "vuid": "VUID-VkSubpassDescription-flags-03344",
+          "text": " If <code>flags</code> includes <code>VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM</code>, then the sample count of the input attachments <strong class=\"purple\">must</strong> equal <code>rasterizationSamples</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDescription-flags-03345",
+          "text": " If <code>flags</code> includes <code>VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM</code>, and if <code>sampleShadingEnable</code> is enabled (explicitly or implicitly) then <code>minSampleShading</code> <strong class=\"purple\">must</strong> equal 0.0"
+        }
+      ],
       "(VK_QCOM_render_pass_transform)": [
         {
           "vuid": "VUID-VkSubpassDescription-pInputAttachments-02868",
@@ -4628,7 +4650,7 @@
         },
         {
           "vuid": "VUID-VkSubpassDependency2-viewOffset-03093",
-          "text": " If <code>viewOffset</code> is not <code>0</code>, <code>srcSubpass</code> <strong class=\"purple\">must</strong> not be equal to <code>dstSubpass</code>."
+          "text": " If <code>viewOffset</code> is not <code>0</code>, <code>srcSubpass</code> <strong class=\"purple\">must</strong> not be equal to <code>dstSubpass</code>"
         },
         {
           "vuid": "VUID-VkSubpassDependency2-sType-sType",
@@ -4746,7 +4768,7 @@
         },
         {
           "vuid": "VUID-VkFramebufferCreateInfo-flags-02778",
-          "text": " If <code>flags</code> does not include <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT</code>, and <code>attachmentCount</code> is not <code>0</code>, <code>pAttachments</code> must be a valid pointer to an array of <code>attachmentCount</code> valid <a href=\"#VkImageView\">VkImageView</a> handles"
+          "text": " If <code>flags</code> does not include <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT</code>, and <code>attachmentCount</code> is not <code>0</code>, <code>pAttachments</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>attachmentCount</code> valid <a href=\"#VkImageView\">VkImageView</a> handles"
         },
         {
           "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00877",
@@ -5414,7 +5436,7 @@
         },
         {
           "vuid": "VUID-VkRenderPassTransformBeginInfoQCOM-flags-02872",
-          "text": " The <code>renderpass</code> must have been created with <a href=\"#VkRenderPassCreateInfo\">VkRenderPassCreateInfo</a>::<code>flags</code> containing <code>VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM</code>"
+          "text": " The <code>renderpass</code> <strong class=\"purple\">must</strong> have been created with <a href=\"#VkRenderPassCreateInfo\">VkRenderPassCreateInfo</a>::<code>flags</code> containing <code>VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM</code>"
         },
         {
           "vuid": "VUID-VkRenderPassTransformBeginInfoQCOM-sType-sType",
@@ -6804,7 +6826,7 @@
         },
         {
           "vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02881",
-          "text": " The state of the first element of <code>pGroups</code> must match its equivalent within the parent&#8217;s <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>"
+          "text": " The state of the first element of <code>pGroups</code> <strong class=\"purple\">must</strong> match its equivalent within the parent&#8217;s <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02882",
@@ -7186,11 +7208,11 @@
       "(VK_NV_device_generated_commands)": [
         {
           "vuid": "VUID-vkCmdBindPipelineShaderGroupNV-groupIndex-02893",
-          "text": " <code>groupIndex</code> must be <code>0</code> or less than the effective <a href=\"#VkGraphicsPipelineShaderGroupsCreateInfoNV\">VkGraphicsPipelineShaderGroupsCreateInfoNV</a>::<code>groupCount</code> including the referenced pipelines"
+          "text": " <code>groupIndex</code> <strong class=\"purple\">must</strong> be <code>0</code> or less than the effective <a href=\"#VkGraphicsPipelineShaderGroupsCreateInfoNV\">VkGraphicsPipelineShaderGroupsCreateInfoNV</a>::<code>groupCount</code> including the referenced pipelines"
         },
         {
           "vuid": "VUID-vkCmdBindPipelineShaderGroupNV-pipelineBindPoint-02894",
-          "text": " The <code>pipelineBindPoint</code> must be <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
+          "text": " The <code>pipelineBindPoint</code> <strong class=\"purple\">must</strong> be <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
         },
         {
           "vuid": "VUID-vkCmdBindPipelineShaderGroupNV-groupIndex-02895",
@@ -8110,7 +8132,7 @@
         },
         {
           "vuid": "VUID-vkAllocateMemory-pAllocateInfo-01714",
-          "text": " <code>pAllocateInfo-&gt;memoryTypeIndex</code> <strong class=\"purple\">must</strong> be less than <a href=\"#VkPhysicalDeviceMemoryProperties\">VkPhysicalDeviceMemoryProperties</a>::<code>memoryTypeCount</code> as returned by <a href=\"#vkGetPhysicalDeviceMemoryProperties\">vkGetPhysicalDeviceMemoryProperties</a> for the <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> that <code>device</code> was created from."
+          "text": " <code>pAllocateInfo-&gt;memoryTypeIndex</code> <strong class=\"purple\">must</strong> be less than <a href=\"#VkPhysicalDeviceMemoryProperties\">VkPhysicalDeviceMemoryProperties</a>::<code>memoryTypeCount</code> as returned by <a href=\"#vkGetPhysicalDeviceMemoryProperties\">vkGetPhysicalDeviceMemoryProperties</a> for the <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> that <code>device</code> was created from"
         },
         {
           "vuid": "VUID-vkAllocateMemory-device-parameter",
@@ -8146,7 +8168,7 @@
       "(VK_KHR_external_memory)+(VK_KHR_dedicated_allocation,VK_NV_dedicated_allocation)": [
         {
           "vuid": "VUID-VkMemoryAllocateInfo-pNext-00639",
-          "text": "     If the <code>pNext</code> chain includes a <code>VkExportMemoryAllocateInfo</code>     structure, and any of the handle types specified in     <code>VkExportMemoryAllocateInfo</code>::<code>handleTypes</code> require a dedicated     allocation, as reported by     <a href=\"#vkGetPhysicalDeviceImageFormatProperties2\">vkGetPhysicalDeviceImageFormatProperties2</a> in     <code>VkExternalImageFormatProperties</code>::<code>externalMemoryProperties.externalMemoryFeatures</code>     or     <code>VkExternalBufferProperties</code>::<code>externalMemoryProperties.externalMemoryFeatures</code>,     the <code>pNext</code> chain must include a ifdef::VK_KHR_dedicated_allocation[<a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>]"
+          "text": "     If the <code>pNext</code> chain includes a <code>VkExportMemoryAllocateInfo</code>     structure, and any of the handle types specified in     <code>VkExportMemoryAllocateInfo</code>::<code>handleTypes</code> require a dedicated     allocation, as reported by     <a href=\"#vkGetPhysicalDeviceImageFormatProperties2\">vkGetPhysicalDeviceImageFormatProperties2</a> in     <code>VkExternalImageFormatProperties</code>::<code>externalMemoryProperties.externalMemoryFeatures</code>     or     <code>VkExternalBufferProperties</code>::<code>externalMemoryProperties.externalMemoryFeatures</code>,     the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a ifdef::VK_KHR_dedicated_allocation[<a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>]"
         }
       ],
       "(VK_KHR_external_memory)+(VK_NV_external_memory)": [
@@ -8366,17 +8388,17 @@
         },
         {
           "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01877",
-          "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, and the external handle was created by the Vulkan API, then the memory being imported <strong class=\"purple\">must</strong> also be a dedicated buffer allocation and <code>buffer</code> must be identical to the buffer associated with the imported memory"
+          "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, and the external handle was created by the Vulkan API, then the memory being imported <strong class=\"purple\">must</strong> also be a dedicated buffer allocation and <code>buffer</code> <strong class=\"purple\">must</strong> be identical to the buffer associated with the imported memory"
         }
       ],
       "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_fd)": [
         {
           "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01878",
-          "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated image allocation and <code>image</code> must be identical to the image associated with the imported memory"
+          "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated image allocation and <code>image</code> <strong class=\"purple\">must</strong> be identical to the image associated with the imported memory"
         },
         {
           "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01879",
-          "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated buffer allocation and <code>buffer</code> must be identical to the buffer associated with the imported memory"
+          "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated buffer allocation and <code>buffer</code> <strong class=\"purple\">must</strong> be identical to the buffer associated with the imported memory"
         }
       ],
       "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_sampler_ycbcr_conversion)": [
@@ -8508,7 +8530,7 @@
         },
         {
           "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441",
-          "text": " if <code>handle</code> is not <code>NULL</code>, <code>name</code> must be <code>NULL</code>"
+          "text": " if <code>handle</code> is not <code>NULL</code>, <code>name</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
         },
         {
           "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-01518",
@@ -9782,7 +9804,7 @@
         },
         {
           "vuid": "VUID-VkImageCreateInfo-initialLayout-00993",
-          "text": " <code>initialLayout</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_LAYOUT_UNDEFINED</code> or <code>VK_IMAGE_LAYOUT_PREINITIALIZED</code>."
+          "text": " <code>initialLayout</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_LAYOUT_UNDEFINED</code> or <code>VK_IMAGE_LAYOUT_PREINITIALIZED</code>"
         },
         {
           "vuid": "VUID-VkImageCreateInfo-sType-sType",
@@ -9982,7 +10004,7 @@
         },
         {
           "vuid": "VUID-VkImageCreateInfo-format-02562",
-          "text": " If the image <code>format</code> is one of those listed in <a href=\"#formats-requiring-sampler-ycbcr-conversion\">Formats requiring sampler Y′C<sub>B</sub>C<sub>R</sub> conversion for <code>VK_IMAGE_ASPECT_COLOR_BIT</code> image views</a>, <code>samples</code> must be <code>VK_SAMPLE_COUNT_1_BIT</code>"
+          "text": " If the image <code>format</code> is one of those listed in <a href=\"#formats-requiring-sampler-ycbcr-conversion\">Formats requiring sampler Y′C<sub>B</sub>C<sub>R</sub> conversion for <code>VK_IMAGE_ASPECT_COLOR_BIT</code> image views</a>, <code>samples</code> <strong class=\"purple\">must</strong> be <code>VK_SAMPLE_COUNT_1_BIT</code>"
         },
         {
           "vuid": "VUID-VkImageCreateInfo-format-02563",
@@ -10208,7 +10230,7 @@
       "(VK_EXT_image_drm_format_modifier)": [
         {
           "vuid": "VUID-VkImageDrmFormatModifierListCreateInfoEXT-pDrmFormatModifiers-02263",
-          "text": " Each <em>modifier</em> in <code>pDrmFormatModifiers</code> must be compatible with the parameters in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> and its <code>pNext</code> chain, as determined by querying <a href=\"#VkPhysicalDeviceImageFormatInfo2\">VkPhysicalDeviceImageFormatInfo2</a> extended with <a href=\"#VkPhysicalDeviceImageDrmFormatModifierInfoEXT\">VkPhysicalDeviceImageDrmFormatModifierInfoEXT</a>"
+          "text": " Each <em>modifier</em> in <code>pDrmFormatModifiers</code> <strong class=\"purple\">must</strong> be compatible with the parameters in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> and its <code>pNext</code> chain, as determined by querying <a href=\"#VkPhysicalDeviceImageFormatInfo2\">VkPhysicalDeviceImageFormatInfo2</a> extended with <a href=\"#VkPhysicalDeviceImageDrmFormatModifierInfoEXT\">VkPhysicalDeviceImageDrmFormatModifierInfoEXT</a>"
         },
         {
           "vuid": "VUID-VkImageDrmFormatModifierListCreateInfoEXT-sType-sType",
@@ -10228,7 +10250,7 @@
       "(VK_EXT_image_drm_format_modifier)": [
         {
           "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifier-02264",
-          "text": " <code>drmFormatModifier</code> must be compatible with the parameters in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> and its <code>pNext</code> chain, as determined by querying <a href=\"#VkPhysicalDeviceImageFormatInfo2\">VkPhysicalDeviceImageFormatInfo2</a> extended with <a href=\"#VkPhysicalDeviceImageDrmFormatModifierInfoEXT\">VkPhysicalDeviceImageDrmFormatModifierInfoEXT</a>"
+          "text": " <code>drmFormatModifier</code> <strong class=\"purple\">must</strong> be compatible with the parameters in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> and its <code>pNext</code> chain, as determined by querying <a href=\"#VkPhysicalDeviceImageFormatInfo2\">VkPhysicalDeviceImageFormatInfo2</a> extended with <a href=\"#VkPhysicalDeviceImageDrmFormatModifierInfoEXT\">VkPhysicalDeviceImageDrmFormatModifierInfoEXT</a>"
         },
         {
           "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifierPlaneCount-02265",
@@ -10919,6 +10941,12 @@
       ]
     },
     "vkGetBufferMemoryRequirements": {
+      "(VK_ANDROID_external_memory_android_hardware_buffer)": [
+        {
+          "vuid": "VUID-vkGetBufferMemoryRequirements-buffer-04003",
+          "text": " If <code>buffer</code> was created with the <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> external memory handle type, then <code>buffer</code> <strong class=\"purple\">must</strong> be bound to memory."
+        }
+      ],
       "core": [
         {
           "vuid": "VUID-vkGetBufferMemoryRequirements-device-parameter",
@@ -10945,6 +10973,12 @@
           "text": " <code>image</code> <strong class=\"purple\">must</strong> not have been created with the <code>VK_IMAGE_CREATE_DISJOINT_BIT</code> flag set"
         }
       ],
+      "(VK_ANDROID_external_memory_android_hardware_buffer)": [
+        {
+          "vuid": "VUID-vkGetImageMemoryRequirements-image-04004",
+          "text": " If <code>image</code> was created with the <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> external memory handle type, then <code>image</code> <strong class=\"purple\">must</strong> be bound to memory."
+        }
+      ],
       "core": [
         {
           "vuid": "VUID-vkGetImageMemoryRequirements-device-parameter",
@@ -10981,6 +11015,12 @@
       ]
     },
     "VkBufferMemoryRequirementsInfo2": {
+      "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_ANDROID_external_memory_android_hardware_buffer)": [
+        {
+          "vuid": "VUID-VkBufferMemoryRequirementsInfo2-buffer-04005",
+          "text": " If <code>buffer</code> was created with the <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> external memory handle type, then <code>buffer</code> <strong class=\"purple\">must</strong> be bound to memory."
+        }
+      ],
       "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [
         {
           "vuid": "VUID-VkBufferMemoryRequirementsInfo2-sType-sType",
@@ -11193,12 +11233,24 @@
         {
           "vuid": "VUID-vkBindBufferMemory-memory-02726",
           "text": " If the value of <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> used to allocate <code>memory</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> include at least one of the handles set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> when <code>buffer</code> was created"
-        },
+        }
+      ],
+      "(VK_VERSION_1_1,VK_KHR_external_memory)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [
         {
           "vuid": "VUID-vkBindBufferMemory-memory-02727",
           "text": " If <code>memory</code> was created by a memory import operation, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> when <code>buffer</code> was created"
         }
       ],
+      "(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_ANDROID_external_memory_android_hardware_buffer)": [
+        {
+          "vuid": "VUID-vkBindBufferMemory-memory-02985",
+          "text": " If <code>memory</code> was created by a memory import operation, that is not <a href=\"#VkImportAndroidHardwareBufferInfoANDROID\">VkImportAndroidHardwareBufferInfoANDROID</a> with a non-<code>NULL</code> <code>buffer</code> value, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> when <code>buffer</code> was created"
+        },
+        {
+          "vuid": "VUID-vkBindBufferMemory-memory-02986",
+          "text": " If <code>memory</code> was created with the <a href=\"#VkImportAndroidHardwareBufferInfoANDROID\">VkImportAndroidHardwareBufferInfoANDROID</a> memory import operation with a non-<code>NULL</code> <code>buffer</code> value, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> when <code>buffer</code> was created"
+        }
+      ],
       "(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [
         {
           "vuid": "VUID-vkBindBufferMemory-bufferDeviceAddress-03339",
@@ -11305,12 +11357,24 @@
         {
           "vuid": "VUID-VkBindBufferMemoryInfo-handleTypes-02791",
           "text": " If the value of <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> used to allocate <code>memory</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> include at least one of the handles set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> when <code>buffer</code> was created"
-        },
+        }
+      ],
+      "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [
         {
           "vuid": "VUID-VkBindBufferMemoryInfo-memory-02792",
           "text": " If <code>memory</code> was created by a memory import operation, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> when <code>buffer</code> was created"
         }
       ],
+      "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_ANDROID_external_memory_android_hardware_buffer)": [
+        {
+          "vuid": "VUID-VkBindBufferMemoryInfo-memory-02987",
+          "text": " If <code>memory</code> was created by a memory import operation, that is not <a href=\"#VkImportAndroidHardwareBufferInfoANDROID\">VkImportAndroidHardwareBufferInfoANDROID</a> with a non-<code>NULL</code> <code>buffer</code> value, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> when <code>buffer</code> was created"
+        },
+        {
+          "vuid": "VUID-VkBindBufferMemoryInfo-memory-02988",
+          "text": " If <code>memory</code> was created with the <a href=\"#VkImportAndroidHardwareBufferInfoANDROID\">VkImportAndroidHardwareBufferInfoANDROID</a> memory import operation with a non-<code>NULL</code> <code>buffer</code> value, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> when <code>buffer</code> was created"
+        }
+      ],
       "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_KHR_buffer_device_address)": [
         {
           "vuid": "VUID-VkBindBufferMemoryInfo-bufferDeviceAddress-02838",
@@ -11439,11 +11503,23 @@
         {
           "vuid": "VUID-vkBindImageMemory-memory-02728",
           "text": " If the value of <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> used to allocate <code>memory</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> include at least one of the handles set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created"
-        },
+        }
+      ],
+      "(VK_VERSION_1_1,VK_KHR_external_memory)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [
         {
           "vuid": "VUID-vkBindImageMemory-memory-02729",
           "text": " If <code>memory</code> was created by a memory import operation, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created"
         }
+      ],
+      "(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_ANDROID_external_memory_android_hardware_buffer)": [
+        {
+          "vuid": "VUID-vkBindImageMemory-memory-02989",
+          "text": " If <code>memory</code> was created by a memory import operation, that is not <a href=\"#VkImportAndroidHardwareBufferInfoANDROID\">VkImportAndroidHardwareBufferInfoANDROID</a> with a non-<code>NULL</code> <code>buffer</code> value, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created"
+        },
+        {
+          "vuid": "VUID-vkBindImageMemory-memory-02990",
+          "text": " If <code>memory</code> was created with the <a href=\"#VkImportAndroidHardwareBufferInfoANDROID\">VkImportAndroidHardwareBufferInfoANDROID</a> memory import operation with a non-<code>NULL</code> <code>buffer</code> value, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created"
+        }
       ]
     },
     "vkBindImageMemory2": {
@@ -11451,6 +11527,10 @@
         {
           "vuid": "VUID-vkBindImageMemory2-pBindInfos-02858",
           "text": " If any <a href=\"#VkBindImageMemoryInfo\">VkBindImageMemoryInfo</a>::image was created with <code>VK_IMAGE_CREATE_DISJOINT_BIT</code> then all planes of <a href=\"#VkBindImageMemoryInfo\">VkBindImageMemoryInfo</a>::image <strong class=\"purple\">must</strong> be bound individually in separate <code>pBindInfos</code>"
+        },
+        {
+          "vuid": "VUID-vkBindImageMemory2-pBindInfos-04006",
+          "text": " <code>pBindInfos</code> <strong class=\"purple\">must</strong> not refer to the same image subresource more than once."
         }
       ],
       "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [
@@ -11602,7 +11682,7 @@
         },
         {
           "vuid": "VUID-VkBindImageMemoryInfo-pNext-01629",
-          "text": " If the <code>pNext</code> chain includes a <a href=\"#VkBindImageMemoryDeviceGroupInfo\">VkBindImageMemoryDeviceGroupInfo</a> structure, the union of the areas of all elements of <a href=\"#VkBindImageMemoryDeviceGroupInfo\">VkBindImageMemoryDeviceGroupInfo</a>::<code>pSplitInstanceBindRegions</code> that correspond to the same instance of <code>image</code> <strong class=\"purple\">must</strong> cover the entire image."
+          "text": " If the <code>pNext</code> chain includes a <a href=\"#VkBindImageMemoryDeviceGroupInfo\">VkBindImageMemoryDeviceGroupInfo</a> structure, the union of the areas of all elements of <a href=\"#VkBindImageMemoryDeviceGroupInfo\">VkBindImageMemoryDeviceGroupInfo</a>::<code>pSplitInstanceBindRegions</code> that correspond to the same instance of <code>image</code> <strong class=\"purple\">must</strong> cover the entire image"
         }
       ],
       "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [
@@ -11623,11 +11703,23 @@
         {
           "vuid": "VUID-VkBindImageMemoryInfo-handleTypes-02793",
           "text": " If the value of <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> used to allocate <code>memory</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> include at least one of the handles set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created"
-        },
+        }
+      ],
+      "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [
         {
           "vuid": "VUID-VkBindImageMemoryInfo-memory-02794",
           "text": " If <code>memory</code> was created by a memory import operation, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created"
         }
+      ],
+      "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_ANDROID_external_memory_android_hardware_buffer)": [
+        {
+          "vuid": "VUID-VkBindImageMemoryInfo-memory-02991",
+          "text": " If <code>memory</code> was created by a memory import operation, that is not <a href=\"#VkImportAndroidHardwareBufferInfoANDROID\">VkImportAndroidHardwareBufferInfoANDROID</a> with a non-<code>NULL</code> <code>buffer</code> value, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created"
+        },
+        {
+          "vuid": "VUID-VkBindImageMemoryInfo-memory-02992",
+          "text": " If <code>memory</code> was created with the <a href=\"#VkImportAndroidHardwareBufferInfoANDROID\">VkImportAndroidHardwareBufferInfoANDROID</a> memory import operation with a non-<code>NULL</code> <code>buffer</code> value, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created"
+        }
       ]
     },
     "VkBindImageMemoryDeviceGroupInfo": {
@@ -11863,12 +11955,16 @@
           "text": " If <code>compactedSize</code> is not <code>0</code> then <code>maxGeometryCount</code> <strong class=\"purple\">must</strong> be <code>0</code>"
         },
         {
+          "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-compactedSize-02993",
+          "text": " If <code>compactedSize</code> is <code>0</code> then <code>maxGeometryCount</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
+        },
+        {
           "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-type-03491",
           "text": " If <code>type</code> is <code>VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR</code> then <code>maxGeometryCount</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceRayTracingPropertiesKHR\">VkPhysicalDeviceRayTracingPropertiesKHR</a>::<code>maxGeometryCount</code>"
         },
         {
           "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-type-03492",
-          "text": " If <code>type</code> is <code>VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR</code> then <code>pGeometryInfos-&gt;maxPrimitiveCount</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceRayTracingPropertiesKHR\">VkPhysicalDeviceRayTracingPropertiesKHR</a>::<code>maxInstanceCount</code>"
+          "text": " If <code>type</code> is <code>VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR</code> then the <code>maxPrimitiveCount</code> member of each element of the <code>pGeometryInfos</code> array <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceRayTracingPropertiesKHR\">VkPhysicalDeviceRayTracingPropertiesKHR</a>::<code>maxInstanceCount</code>"
         },
         {
           "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-maxPrimitiveCount-03493",
@@ -11920,11 +12016,7 @@
         },
         {
           "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-pGeometryInfos-parameter",
-          "text": " <code>pGeometryInfos</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>maxGeometryCount</code> valid <a href=\"#VkAccelerationStructureCreateGeometryTypeInfoKHR\">VkAccelerationStructureCreateGeometryTypeInfoKHR</a> structures"
-        },
-        {
-          "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-maxGeometryCount-arraylength",
-          "text": " <code>maxGeometryCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+          "text": " If <code>maxGeometryCount</code> is not <code>0</code>, <code>pGeometryInfos</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>maxGeometryCount</code> valid <a href=\"#VkAccelerationStructureCreateGeometryTypeInfoKHR\">VkAccelerationStructureCreateGeometryTypeInfoKHR</a> structures"
         }
       ]
     },
@@ -12758,7 +12850,7 @@
       "core": [
         {
           "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-binding-00279",
-          "text": " The <a href=\"#VkDescriptorSetLayoutBinding\">VkDescriptorSetLayoutBinding</a>::<code>binding</code> members of the elements of the <code>pBindings</code> array <strong class=\"purple\">must</strong> each have different values."
+          "text": " The <a href=\"#VkDescriptorSetLayoutBinding\">VkDescriptorSetLayoutBinding</a>::<code>binding</code> members of the elements of the <code>pBindings</code> array <strong class=\"purple\">must</strong> each have different values"
         },
         {
           "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-sType-sType",
@@ -13432,11 +13524,11 @@
         },
         {
           "vuid": "VUID-vkAllocateDescriptorSets-pDescriptorSets-parameter",
-          "text": " <code>pDescriptorSets</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pAllocateInfo</code>::descriptorSetCount <a href=\"#VkDescriptorSet\">VkDescriptorSet</a> handles"
+          "text": " <code>pDescriptorSets</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pAllocateInfo-&gt;descriptorSetCount</code> <a href=\"#VkDescriptorSet\">VkDescriptorSet</a> handles"
         },
         {
           "vuid": "VUID-vkAllocateDescriptorSets-pAllocateInfo::descriptorSetCount-arraylength",
-          "text": " The value referenced by <code>pAllocateInfo</code>::<code>descriptorSetCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+          "text": " The value referenced by <code>pAllocateInfo-&gt;descriptorSetCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
         }
       ]
     },
@@ -13641,8 +13733,12 @@
           "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_SAMPLER</code>, <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code>, <code>VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE</code>, <code>VK_DESCRIPTOR_TYPE_STORAGE_IMAGE</code>, or <code>VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT</code>, <code>pImageInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>descriptorCount</code> valid <code>VkDescriptorImageInfo</code> structures"
         },
         {
-          "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00323",
-          "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER</code> or <code>VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER</code>, <code>pTexelBufferView</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>descriptorCount</code> valid <code>VkBufferView</code> handles"
+          "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02994",
+          "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER</code> or <code>VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER</code>, each element of <code>pTexelBufferView</code> <strong class=\"purple\">must</strong> be either a valid <code>VkBufferView</code> handle or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
+        },
+        {
+          "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02995",
+          "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER</code> or <code>VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER</code> and the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, each element of <code>pTexelBufferView</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00324",
@@ -13653,8 +13749,12 @@
           "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_SAMPLER</code> or <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code>, and <code>dstSet</code> was not allocated with a layout that included immutable samplers for <code>dstBinding</code> with <code>descriptorType</code>, the <code>sampler</code> member of each element of <code>pImageInfo</code> <strong class=\"purple\">must</strong> be a valid <code>VkSampler</code> object"
         },
         {
-          "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00326",
-          "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code>, <code>VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE</code>, <code>VK_DESCRIPTOR_TYPE_STORAGE_IMAGE</code>, or <code>VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT</code>, the <code>imageView</code> and <code>imageLayout</code> members of each element of <code>pImageInfo</code> <strong class=\"purple\">must</strong> be a valid <code>VkImageView</code> and <a href=\"#VkImageLayout\">VkImageLayout</a>, respectively"
+          "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02996",
+          "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code>, <code>VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE</code>, <code>VK_DESCRIPTOR_TYPE_STORAGE_IMAGE</code>, or <code>VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT</code>, the <code>imageView</code> member of each element of <code>pImageInfo</code> <strong class=\"purple\">must</strong> be either a valid <code>VkImageView</code> handle or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
+        },
+        {
+          "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02997",
+          "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code>, <code>VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE</code>, <code>VK_DESCRIPTOR_TYPE_STORAGE_IMAGE</code>, or <code>VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT</code> and the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, the <code>imageView</code> member of each element of <code>pImageInfo</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01402",
@@ -13801,8 +13901,18 @@
           "text": " If <code>range</code> is not equal to <code>VK_WHOLE_SIZE</code>, <code>range</code> <strong class=\"purple\">must</strong> be less than or equal to the size of <code>buffer</code> minus <code>offset</code>"
         },
         {
+          "vuid": "VUID-VkDescriptorBufferInfo-buffer-02998",
+          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, <code>buffer</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
+        },
+        {
           "vuid": "VUID-VkDescriptorBufferInfo-buffer-parameter",
-          "text": " <code>buffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkBuffer\">VkBuffer</a> handle"
+          "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>buffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkBuffer\">VkBuffer</a> handle"
+        }
+      ],
+      "(VK_EXT_robustness2)": [
+        {
+          "vuid": "VUID-VkDescriptorBufferInfo-buffer-02999",
+          "text": " If <code>buffer</code> is <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>offset</code> <strong class=\"purple\">must</strong> be zero and <code>range</code> <strong class=\"purple\">must</strong> be <code>VK_WHOLE_SIZE</code>"
         }
       ]
     },
@@ -15572,15 +15682,15 @@
       "(VK_VERSION_1_2,VK_EXT_separate_stencil_usage)": [
         {
           "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-02658",
-          "text": " If any element of <code>pRanges.aspect</code> includes <code>VK_IMAGE_ASPECT_STENCIL_BIT</code>, and <code>image</code> was created with <a href=\"#VkImageStencilUsageCreateInfo\">separate stencil usage</a>, <code>VK_IMAGE_USAGE_TRANSFER_DST_BIT</code> <strong class=\"purple\">must</strong> have been included in the <a href=\"#VkImageStencilUsageCreateInfo\">VkImageStencilUsageCreateInfo</a>::<code>stencilUsage</code> used to create <code>image</code>"
+          "text": " If the <code>aspect</code> member of any element of <code>pRanges</code> includes <code>VK_IMAGE_ASPECT_STENCIL_BIT</code>, and <code>image</code> was created with <a href=\"#VkImageStencilUsageCreateInfo\">separate stencil usage</a>, <code>VK_IMAGE_USAGE_TRANSFER_DST_BIT</code> <strong class=\"purple\">must</strong> have been included in the <a href=\"#VkImageStencilUsageCreateInfo\">VkImageStencilUsageCreateInfo</a>::<code>stencilUsage</code> used to create <code>image</code>"
         },
         {
           "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-02659",
-          "text": " If any element of <code>pRanges.aspect</code> includes <code>VK_IMAGE_ASPECT_STENCIL_BIT</code>, and <code>image</code> was not created with <a href=\"#VkImageStencilUsageCreateInfo\">separate stencil usage</a>, <code>VK_IMAGE_USAGE_TRANSFER_DST_BIT</code> <strong class=\"purple\">must</strong> have been included in the <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>usage</code> used to create <code>image</code>"
+          "text": " If the <code>aspect</code> member of any element of <code>pRanges</code> includes <code>VK_IMAGE_ASPECT_STENCIL_BIT</code>, and <code>image</code> was not created with <a href=\"#VkImageStencilUsageCreateInfo\">separate stencil usage</a>, <code>VK_IMAGE_USAGE_TRANSFER_DST_BIT</code> <strong class=\"purple\">must</strong> have been included in the <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>usage</code> used to create <code>image</code>"
         },
         {
           "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-02660",
-          "text": " If any element of <code>pRanges.aspect</code> includes <code>VK_IMAGE_ASPECT_DEPTH_BIT</code>, <code>VK_IMAGE_USAGE_TRANSFER_DST_BIT</code> <strong class=\"purple\">must</strong> have been included in the <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>usage</code> used to create <code>image</code>"
+          "text": " If the <code>aspect</code> member of any element of <code>pRanges</code> includes <code>VK_IMAGE_ASPECT_DEPTH_BIT</code>, <code>VK_IMAGE_USAGE_TRANSFER_DST_BIT</code> <strong class=\"purple\">must</strong> have been included in the <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>usage</code> used to create <code>image</code>"
         }
       ],
       "core": [
@@ -16406,7 +16516,7 @@
         },
         {
           "vuid": "VUID-VkImageCopy-dstImage-01788",
-          "text": " If the calling command&#8217;s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_2D</code>, then <code>dstOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code>."
+          "text": " If the calling command&#8217;s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_2D</code>, then <code>dstOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code>"
         },
         {
           "vuid": "VUID-VkImageCopy-dstOffset-00150",
@@ -16874,7 +16984,7 @@
         },
         {
           "vuid": "VUID-vkCmdBlitImage-srcImage-01999",
-          "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>srcImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_BLIT_SRC_BIT</code>."
+          "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>srcImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_BLIT_SRC_BIT</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-srcImage-00219",
@@ -16890,7 +17000,7 @@
         },
         {
           "vuid": "VUID-vkCmdBlitImage-dstImage-02000",
-          "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>dstImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_BLIT_DST_BIT</code>."
+          "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>dstImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_BLIT_DST_BIT</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-dstImage-00224",
@@ -16930,7 +17040,7 @@
         },
         {
           "vuid": "VUID-vkCmdBlitImage-filter-02001",
-          "text": " If <code>filter</code> is <code>VK_FILTER_LINEAR</code>, then the <a href=\"#resources-image-format-features\">format features</a> of <code>srcImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT</code>."
+          "text": " If <code>filter</code> is <code>VK_FILTER_LINEAR</code>, then the <a href=\"#resources-image-format-features\">format features</a> of <code>srcImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-srcSubresource-01705",
@@ -17542,11 +17652,15 @@
         },
         {
           "vuid": "VUID-vkCmdDraw-None-02687",
-          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command"
         },
         {
-          "vuid": "VUID-vkCmdDraw-None-02720",
-          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have valid buffers bound"
+          "vuid": "VUID-vkCmdDraw-None-04007",
+          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound"
+        },
+        {
+          "vuid": "VUID-vkCmdDraw-None-04008",
+          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-vkCmdDraw-None-02721",
@@ -17692,11 +17806,15 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-None-02687",
-          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexed-None-04007",
+          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound"
         },
         {
-          "vuid": "VUID-vkCmdDrawIndexed-None-02720",
-          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have valid buffers bound"
+          "vuid": "VUID-vkCmdDrawIndexed-None-04008",
+          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-None-02721",
@@ -17846,11 +17964,15 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-None-02687",
-          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirect-None-04007",
+          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound"
         },
         {
-          "vuid": "VUID-vkCmdDrawIndirect-None-02720",
-          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have valid buffers bound"
+          "vuid": "VUID-vkCmdDrawIndirect-None-04008",
+          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirect-None-02721",
@@ -18048,11 +18170,15 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-None-02687",
-          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command"
         },
         {
-          "vuid": "VUID-vkCmdDrawIndirectCount-None-02720",
-          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have valid buffers bound"
+          "vuid": "VUID-vkCmdDrawIndirectCount-None-04007",
+          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectCount-None-04008",
+          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-None-02721",
@@ -18256,11 +18382,15 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02687",
-          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04007",
+          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound"
         },
         {
-          "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02720",
-          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have valid buffers bound"
+          "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04008",
+          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02721",
@@ -18468,11 +18598,15 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02687",
-          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command"
         },
         {
-          "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02720",
-          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have valid buffers bound"
+          "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04007",
+          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04008",
+          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02721",
@@ -18670,11 +18804,15 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02687",
-          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04007",
+          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound"
         },
         {
-          "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02720",
-          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have valid buffers bound"
+          "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04008",
+          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02721",
@@ -18840,11 +18978,11 @@
         },
         {
           "vuid": "VUID-vkCmdEndConditionalRenderingEXT-None-01986",
-          "text": " If conditional rendering was made <a href=\"#active-conditional-rendering\">active</a> outside of a render pass instance, it must not be ended inside a render pass instance"
+          "text": " If conditional rendering was made <a href=\"#active-conditional-rendering\">active</a> outside of a render pass instance, it <strong class=\"purple\">must</strong> not be ended inside a render pass instance"
         },
         {
           "vuid": "VUID-vkCmdEndConditionalRenderingEXT-None-01987",
-          "text": " If conditional rendering was made <a href=\"#active-conditional-rendering\">active</a> within a subpass it must be ended in the same subpass"
+          "text": " If conditional rendering was made <a href=\"#active-conditional-rendering\">active</a> within a subpass it <strong class=\"purple\">must</strong> be ended in the same subpass"
         },
         {
           "vuid": "VUID-vkCmdEndConditionalRenderingEXT-commandBuffer-parameter",
@@ -18928,7 +19066,7 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02687",
-          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-taskCount-02119",
@@ -19066,7 +19204,7 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02687",
-          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-buffer-02708",
@@ -19252,7 +19390,7 @@
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02687",
-          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command"
         },
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-02708",
@@ -19489,12 +19627,16 @@
           "text": " Each element of <code>pBuffers</code> that is non-sparse <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <code>VkDeviceMemory</code> object"
         },
         {
+          "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-04001",
+          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, all elements of <code>pBuffers</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
+        },
+        {
           "vuid": "VUID-vkCmdBindVertexBuffers-commandBuffer-parameter",
           "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle"
         },
         {
           "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-parameter",
-          "text": " <code>pBuffers</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>bindingCount</code> valid <a href=\"#VkBuffer\">VkBuffer</a> handles"
+          "text": " <code>pBuffers</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>bindingCount</code> valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> <a href=\"#VkBuffer\">VkBuffer</a> handles"
         },
         {
           "vuid": "VUID-vkCmdBindVertexBuffers-pOffsets-parameter",
@@ -19514,7 +19656,13 @@
         },
         {
           "vuid": "VUID-vkCmdBindVertexBuffers-commonparent",
-          "text": " Both of <code>commandBuffer</code>, and the elements of <code>pBuffers</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkDevice\">VkDevice</a>"
+          "text": " Both of <code>commandBuffer</code>, and the elements of <code>pBuffers</code> that are valid handles of non-ignored parameters <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkDevice\">VkDevice</a>"
+        }
+      ],
+      "(VK_EXT_robustness2)": [
+        {
+          "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-04002",
+          "text": " If an element of <code>pBuffers</code> is <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then the corresponding element of <code>pOffsets</code> <strong class=\"purple\">must</strong> be zero"
         }
       ]
     },
@@ -20496,7 +20644,7 @@
         },
         {
           "vuid": "VUID-vkCmdSetCoarseSampleOrderNV-pCustomSampleOrders-02235",
-          "text": " The array <code>pCustomSampleOrders</code> <strong class=\"purple\">must</strong> not contain two structures with matching values for both the <code>shadingRate</code> and <code>sampleCount</code> members."
+          "text": " The array <code>pCustomSampleOrders</code> <strong class=\"purple\">must</strong> not contain two structures with matching values for both the <code>shadingRate</code> and <code>sampleCount</code> members"
         },
         {
           "vuid": "VUID-vkCmdSetCoarseSampleOrderNV-commandBuffer-parameter",
@@ -21780,7 +21928,7 @@
         },
         {
           "vuid": "VUID-VkIndirectCommandsStreamNV-offset-02943",
-          "text": " The <code>offset</code> <strong class=\"purple\">must</strong> be aligned to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>minIndirectCommandsBufferOffsetAlignment</code>."
+          "text": " The <code>offset</code> <strong class=\"purple\">must</strong> be aligned to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>minIndirectCommandsBufferOffsetAlignment</code>"
         },
         {
           "vuid": "VUID-VkIndirectCommandsStreamNV-buffer-02975",
@@ -21844,7 +21992,7 @@
         },
         {
           "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-offset-02952",
-          "text": " <code>offset</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>maxIndirectCommandsTokenOffset</code>."
+          "text": " <code>offset</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>maxIndirectCommandsTokenOffset</code>"
         },
         {
           "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02976",
@@ -22036,11 +22184,15 @@
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02687",
-          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command"
+        },
+        {
+          "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04007",
+          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have either valid or <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> buffers bound"
         },
         {
-          "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02720",
-          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have valid buffers bound"
+          "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04008",
+          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02721",
@@ -22052,7 +22204,7 @@
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pipeline-02909",
-          "text": " <code>VkGeneratedCommandsInfoNV</code>::<code>pipeline</code> <strong class=\"purple\">must</strong> match the current bound pipeline at <code>VkGeneratedCommandsInfoNV</code>::<code>pipelineBindPoint</code>."
+          "text": " <code>VkGeneratedCommandsInfoNV</code>::<code>pipeline</code> <strong class=\"purple\">must</strong> match the current bound pipeline at <code>VkGeneratedCommandsInfoNV</code>::<code>pipelineBindPoint</code>"
         },
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-deviceGeneratedCommands-02911",
@@ -22678,7 +22830,7 @@
         },
         {
           "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01117",
-          "text": " All elements of the <code>pWaitSemaphores</code> member of all elements of <code>pBindInfo</code> member referring to a binary semaphore <strong class=\"purple\">must</strong> be semaphores that are signaled, or have <a href=\"#synchronization-semaphores-signaling\">semaphore signal operations</a> previously submitted for execution."
+          "text": " All elements of the <code>pWaitSemaphores</code> member of all elements of <code>pBindInfo</code> member referring to a binary semaphore <strong class=\"purple\">must</strong> be semaphores that are signaled, or have <a href=\"#synchronization-semaphores-signaling\">semaphore signal operations</a> previously submitted for execution"
         },
         {
           "vuid": "VUID-vkQueueBindSparse-queue-parameter",
@@ -24022,7 +24174,7 @@
       "(VK_KHR_surface)": [
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-02739",
-          "text": " <code>surface</code> must be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
+          "text": " <code>surface</code> <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
         },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter",
@@ -24050,7 +24202,7 @@
       "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-02740",
-          "text": " <code>pSurfaceInfo-&gt;surface</code> must be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
+          "text": " <code>pSurfaceInfo-&gt;surface</code> <strong class=\"purple\">must</strong> be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
         },
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter",
@@ -24846,7 +24998,7 @@
         },
         {
           "vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-01295",
-          "text": " All elements of the <code>pWaitSemaphores</code> member of <code>pPresentInfo</code> <strong class=\"purple\">must</strong> be semaphores that are signaled, or have <a href=\"#synchronization-semaphores-signaling\">semaphore signal operations</a> previously submitted for execution."
+          "text": " All elements of the <code>pWaitSemaphores</code> member of <code>pPresentInfo</code> <strong class=\"purple\">must</strong> be semaphores that are signaled, or have <a href=\"#synchronization-semaphores-signaling\">semaphore signal operations</a> previously submitted for execution"
         },
         {
           "vuid": "VUID-vkQueuePresentKHR-queue-parameter",
@@ -25328,7 +25480,7 @@
         },
         {
           "vuid": "VUID-vkCmdTraceRaysNV-maxRecursionDepth-03430",
-          "text": " This command <strong class=\"purple\">must</strong> not cause a shader call instruction to be executed from a shader invocation with a <a href=\"#ray-tracing-recursion-depth\">recursion depth</a> greater than the value of <code>maxRecursionDepth</code> used to create the bound ray tracing pipeline."
+          "text": " This command <strong class=\"purple\">must</strong> not cause a shader call instruction to be executed from a shader invocation with a <a href=\"#ray-tracing-recursion-depth\">recursion depth</a> greater than the value of <code>maxRecursionDepth</code> used to create the bound ray tracing pipeline"
         },
         {
           "vuid": "VUID-vkCmdTraceRaysNV-width-02469",
@@ -25538,7 +25690,7 @@
         },
         {
           "vuid": "VUID-vkCmdTraceRaysKHR-maxRecursionDepth-03430",
-          "text": " This command <strong class=\"purple\">must</strong> not cause a shader call instruction to be executed from a shader invocation with a <a href=\"#ray-tracing-recursion-depth\">recursion depth</a> greater than the value of <code>maxRecursionDepth</code> used to create the bound ray tracing pipeline."
+          "text": " This command <strong class=\"purple\">must</strong> not cause a shader call instruction to be executed from a shader invocation with a <a href=\"#ray-tracing-recursion-depth\">recursion depth</a> greater than the value of <code>maxRecursionDepth</code> used to create the bound ray tracing pipeline"
         },
         {
           "vuid": "VUID-vkCmdTraceRaysKHR-width-03505",
@@ -25788,7 +25940,7 @@
         },
         {
           "vuid": "VUID-vkCmdTraceRaysIndirectKHR-maxRecursionDepth-03430",
-          "text": " This command <strong class=\"purple\">must</strong> not cause a shader call instruction to be executed from a shader invocation with a <a href=\"#ray-tracing-recursion-depth\">recursion depth</a> greater than the value of <code>maxRecursionDepth</code> used to create the bound ray tracing pipeline."
+          "text": " This command <strong class=\"purple\">must</strong> not cause a shader call instruction to be executed from a shader invocation with a <a href=\"#ray-tracing-recursion-depth\">recursion depth</a> greater than the value of <code>maxRecursionDepth</code> used to create the bound ray tracing pipeline"
         },
         {
           "vuid": "VUID-vkCmdTraceRaysIndirectKHR-buffer-02708",
@@ -25998,7 +26150,7 @@
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_ray_tracing)": [
         {
           "vuid": "VUID-vkCmdBuildAccelerationStructureKHR-pOffsetInfos-03402",
-          "text": " <code>pOffsetInfos</code>[i] <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pInfos</code>[i].<code>geometryCount</code> <code>VkAccelerationStructureBuildOffsetInfoKHR</code> structures"
+          "text": " Each element of <code>ppOffsetInfos</code>[i] <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pInfos</code>[i].<code>geometryCount</code> <code>VkAccelerationStructureBuildOffsetInfoKHR</code> structures"
         },
         {
           "vuid": "VUID-vkCmdBuildAccelerationStructureKHR-pInfos-03403",
@@ -26476,7 +26628,7 @@
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_ray_tracing)": [
         {
           "vuid": "VUID-vkCmdCopyAccelerationStructureKHR-None-03556",
-          "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to device memory."
+          "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to device memory"
         },
         {
           "vuid": "VUID-vkCmdCopyAccelerationStructureKHR-commandBuffer-parameter",
@@ -26554,7 +26706,7 @@
         },
         {
           "vuid": "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-None-03559",
-          "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to device memory."
+          "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to device memory"
         },
         {
           "vuid": "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-mode-03412",
@@ -26592,7 +26744,7 @@
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing)": [
         {
           "vuid": "VUID-VkCopyAccelerationStructureToMemoryInfoKHR-dst-03561",
-          "text": " The memory pointed to by <code>dst</code> <strong class=\"purple\">must</strong> be at least as large as the serialization size of <code>src</code>, as reported by <code>VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR</code>."
+          "text": " The memory pointed to by <code>dst</code> <strong class=\"purple\">must</strong> be at least as large as the serialization size of <code>src</code>, as reported by <code>VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR</code>"
         },
         {
           "vuid": "VUID-VkCopyAccelerationStructureToMemoryInfoKHR-mode-03412",
@@ -26632,7 +26784,7 @@
         },
         {
           "vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-None-03563",
-          "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to device memory."
+          "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to device memory"
         },
         {
           "vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-mode-03413",
@@ -26742,7 +26894,7 @@
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing)": [
         {
           "vuid": "VUID-vkBuildAccelerationStructureKHR-pOffsetInfos-03402",
-          "text": " <code>pOffsetInfos</code>[i] <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pInfos</code>[i].<code>geometryCount</code> <code>VkAccelerationStructureBuildOffsetInfoKHR</code> structures"
+          "text": " Each element of <code>ppOffsetInfos</code>[i] <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pInfos</code>[i].<code>geometryCount</code> <code>VkAccelerationStructureBuildOffsetInfoKHR</code> structures"
         },
         {
           "vuid": "VUID-vkBuildAccelerationStructureKHR-pInfos-03403",
@@ -27494,7 +27646,7 @@
       "(VK_KHR_ray_tracing)": [
         {
           "vuid": "VUID-VkPhysicalDeviceRayTracingFeaturesKHR-rayTracingShaderGroupHandleCaptureReplayMixed-03348",
-          "text": " If <code>rayTracingShaderGroupHandleCaptureReplayMixed</code> is <code>VK_TRUE</code>, <code>rayTracingShaderGroupHandleCaptureReplay</code> must also be <code>VK_TRUE</code>"
+          "text": " If <code>rayTracingShaderGroupHandleCaptureReplayMixed</code> is <code>VK_TRUE</code>, <code>rayTracingShaderGroupHandleCaptureReplay</code> <strong class=\"purple\">must</strong> also be <code>VK_TRUE</code>"
         },
         {
           "vuid": "VUID-VkPhysicalDeviceRayTracingFeaturesKHR-sType-sType",
@@ -27526,6 +27678,18 @@
         }
       ]
     },
+    "VkPhysicalDeviceRobustness2FeaturesEXT": {
+      "(VK_EXT_robustness2)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceRobustness2FeaturesEXT-robustBufferAccess2-04000",
+          "text": " If <code>robustBufferAccess2</code> is enabled then <a href=\"#features-robustBufferAccess\"><code>robustBufferAccess</code></a> <strong class=\"purple\">must</strong> also be enabled"
+        },
+        {
+          "vuid": "VUID-VkPhysicalDeviceRobustness2FeaturesEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT</code>"
+        }
+      ]
+    },
     "VkPhysicalDevicePushDescriptorPropertiesKHR": {
       "(VK_KHR_push_descriptor)": [
         {
@@ -27798,6 +27962,14 @@
         }
       ]
     },
+    "VkPhysicalDeviceRobustness2PropertiesEXT": {
+      "(VK_EXT_robustness2)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceRobustness2PropertiesEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV": {
       "(VK_NV_device_generated_commands)": [
         {
diff --git a/registry/vk.xml b/registry/vk.xml
index 7a04c93..1efa424 100644
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -157,7 +157,7 @@ server.
         <type category="define">// Vulkan 1.2 version number
 #define <name>VK_API_VERSION_1_2</name> <type>VK_MAKE_VERSION</type>(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> 137</type>
+#define <name>VK_HEADER_VERSION</name> 139</type>
         <type category="define" requires="VK_HEADER_VERSION">// Complete version of this file
 #define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_VERSION</type>(1, 2, VK_HEADER_VERSION)</type>
 
@@ -847,7 +847,7 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>VkDeviceSize</type>           <name>maxResourceSize</name><comment>max size (in bytes) of this resource type</comment></member>
         </type>
         <type category="struct" name="VkDescriptorBufferInfo">
-            <member><type>VkBuffer</type>               <name>buffer</name><comment>Buffer used for this descriptor slot.</comment></member>
+            <member optional="true"><type>VkBuffer</type>               <name>buffer</name><comment>Buffer used for this descriptor slot.</comment></member>
             <member><type>VkDeviceSize</type>           <name>offset</name><comment>Base offset from buffer start in bytes to update in the descriptor set.</comment></member>
             <member><type>VkDeviceSize</type>           <name>range</name><comment>Size in bytes of the buffer resource for this descriptor update.</comment></member>
         </type>
@@ -4696,7 +4696,7 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>VkDeviceSize</type>                                            <name>compactedSize</name></member>
             <member><type>VkAccelerationStructureTypeKHR</type>                          <name>type</name></member>
             <member optional="true"><type>VkBuildAccelerationStructureFlagsKHR</type>    <name>flags</name></member>
-            <member><type>uint32_t</type>                                                <name>maxGeometryCount</name></member>
+            <member optional="true"><type>uint32_t</type>                                <name>maxGeometryCount</name></member>
             <member len="maxGeometryCount">const <type>VkAccelerationStructureCreateGeometryTypeInfoKHR</type>* <name>pGeometryInfos</name></member>
             <member optional="true"><type>VkDeviceAddress</type>                         <name>deviceAddress</name></member>
         </type>
@@ -4714,6 +4714,7 @@ typedef void <name>CAMetalLayer</name>;
         </type>
         <type category="struct" name="VkTransformMatrixNV" alias="VkTransformMatrixKHR"/>
         <type category="struct" name="VkAccelerationStructureInstanceKHR">
+            <comment>The bitfields in this structure are non-normative since bitfield ordering is implementation-defined in C. The specification defines the normative layout.</comment>
             <member><type>VkTransformMatrixKHR</type>                                    <name>transform</name></member>
             <member><type>uint32_t</type>                                                <name>instanceCustomIndex</name>:24</member>
             <member><type>uint32_t</type>                                                <name>mask</name>:8</member>
@@ -4792,7 +4793,20 @@ typedef void <name>CAMetalLayer</name>;
             <member>const <type>void</type>*                                         <name>pNext</name></member>
             <member optional="true"><type>VkDeviceDiagnosticsConfigFlagsNV</type>    <name>flags</name></member>
         </type>
- </types>
+        <type category="struct" name="VkPhysicalDeviceRobustness2FeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member noautovalidity="true"><type>void</type>*        <name>pNext</name></member>
+            <member><type>VkBool32</type>                           <name>robustBufferAccess2</name></member>
+            <member><type>VkBool32</type>                           <name>robustImageAccess2</name></member>
+            <member><type>VkBool32</type>                           <name>nullDescriptor</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceRobustness2PropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member noautovalidity="true"><type>void</type>*        <name>pNext</name></member>
+            <member><type>VkDeviceSize</type>                       <name>robustStorageBufferAccessSizeAlignment</name></member>
+            <member><type>VkDeviceSize</type>                       <name>robustUniformBufferAccessSizeAlignment</name></member>
+        </type>
+    </types>
 
     <comment>Vulkan enumerant (token) definitions</comment>
 
@@ -6154,6 +6168,9 @@ typedef void <name>CAMetalLayer</name>;
             <proto><type>void</type> <name>vkDestroyInstance</name></proto>
             <param optional="true" externsync="true"><type>VkInstance</type> <name>instance</name></param>
             <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
+            <implicitexternsyncparams>
+                <param>all sname:VkPhysicalDevice objects enumerated from pname:instance</param>
+            </implicitexternsyncparams>
         </command>
         <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
             <proto><type>VkResult</type> <name>vkEnumeratePhysicalDevices</name></proto>
@@ -6661,8 +6678,8 @@ typedef void <name>CAMetalLayer</name>;
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FRAGMENTED_POOL,VK_ERROR_OUT_OF_POOL_MEMORY">
             <proto><type>VkResult</type> <name>vkAllocateDescriptorSets</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
-            <param externsync="pAllocateInfo::descriptorPool">const <type>VkDescriptorSetAllocateInfo</type>* <name>pAllocateInfo</name></param>
-            <param len="pAllocateInfo::descriptorSetCount"><type>VkDescriptorSet</type>* <name>pDescriptorSets</name></param>
+            <param externsync="pAllocateInfo-&gt;descriptorPool">const <type>VkDescriptorSetAllocateInfo</type>* <name>pAllocateInfo</name></param>
+            <param len="pAllocateInfo-&gt;descriptorSetCount"><type>VkDescriptorSet</type>* <name>pDescriptorSets</name></param>
         </command>
         <command successcodes="VK_SUCCESS">
             <proto><type>VkResult</type> <name>vkFreeDescriptorSets</name></proto>
@@ -6733,8 +6750,8 @@ typedef void <name>CAMetalLayer</name>;
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkAllocateCommandBuffers</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
-            <param externsync="pAllocateInfo::commandPool">const <type>VkCommandBufferAllocateInfo</type>* <name>pAllocateInfo</name></param>
-            <param len="pAllocateInfo::commandBufferCount"><type>VkCommandBuffer</type>* <name>pCommandBuffers</name></param>
+            <param externsync="pAllocateInfo-&gt;commandPool">const <type>VkCommandBufferAllocateInfo</type>* <name>pAllocateInfo</name></param>
+            <param len="pAllocateInfo-&gt;commandBufferCount"><type>VkCommandBuffer</type>* <name>pCommandBuffers</name></param>
         </command>
         <command>
             <proto><type>void</type> <name>vkFreeCommandBuffers</name></proto>
@@ -6847,7 +6864,7 @@ typedef void <name>CAMetalLayer</name>;
             <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
             <param><type>uint32_t</type> <name>firstBinding</name></param>
             <param><type>uint32_t</type> <name>bindingCount</name></param>
-            <param len="bindingCount">const <type>VkBuffer</type>* <name>pBuffers</name></param>
+            <param len="bindingCount" optional="false,true">const <type>VkBuffer</type>* <name>pBuffers</name></param>
             <param len="bindingCount">const <type>VkDeviceSize</type>* <name>pOffsets</name></param>
         </command>
         <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary" pipeline="graphics">
@@ -7210,7 +7227,7 @@ typedef void <name>CAMetalLayer</name>;
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_SURFACE_LOST_KHR,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR,VK_ERROR_INITIALIZATION_FAILED">
             <proto><type>VkResult</type> <name>vkCreateSwapchainKHR</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
-            <param externsync="pCreateInfo.surface,pCreateInfo.oldSwapchain">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfo</name></param>
+            <param externsync="pCreateInfo-&gt;surface,pCreateInfo-&gt;oldSwapchain">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfo</name></param>
             <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
             <param><type>VkSwapchainKHR</type>* <name>pSwapchain</name></param>
         </command>
@@ -7239,7 +7256,7 @@ typedef void <name>CAMetalLayer</name>;
         <command successcodes="VK_SUCCESS,VK_SUBOPTIMAL_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_OUT_OF_DATE_KHR,VK_ERROR_SURFACE_LOST_KHR,VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT">
             <proto><type>VkResult</type> <name>vkQueuePresentKHR</name></proto>
             <param externsync="true"><type>VkQueue</type> <name>queue</name></param>
-            <param externsync="pPresentInfo.pWaitSemaphores[],pPresentInfo.pSwapchains[]">const <type>VkPresentInfoKHR</type>* <name>pPresentInfo</name></param>
+            <param externsync="pPresentInfo-&gt;pWaitSemaphores[],pPresentInfo-&gt;pSwapchains[]">const <type>VkPresentInfoKHR</type>* <name>pPresentInfo</name></param>
         </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR">
             <proto><type>VkResult</type> <name>vkCreateViSurfaceNN</name></proto>
@@ -7342,12 +7359,12 @@ typedef void <name>CAMetalLayer</name>;
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkDebugMarkerSetObjectNameEXT</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
-            <param externsync="pNameInfo.object">const <type>VkDebugMarkerObjectNameInfoEXT</type>* <name>pNameInfo</name></param>
+            <param externsync="pNameInfo-&gt;object">const <type>VkDebugMarkerObjectNameInfoEXT</type>* <name>pNameInfo</name></param>
         </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkDebugMarkerSetObjectTagEXT</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
-            <param externsync="pTagInfo.object">const <type>VkDebugMarkerObjectTagInfoEXT</type>* <name>pTagInfo</name></param>
+            <param externsync="pTagInfo-&gt;object">const <type>VkDebugMarkerObjectTagInfoEXT</type>* <name>pTagInfo</name></param>
         </command>
         <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdDebugMarkerBeginEXT</name></proto>
@@ -7976,12 +7993,12 @@ typedef void <name>CAMetalLayer</name>;
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkSetDebugUtilsObjectNameEXT</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
-            <param externsync="pNameInfo.objectHandle">const <type>VkDebugUtilsObjectNameInfoEXT</type>* <name>pNameInfo</name></param>
+            <param externsync="pNameInfo-&gt;objectHandle">const <type>VkDebugUtilsObjectNameInfoEXT</type>* <name>pNameInfo</name></param>
         </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkSetDebugUtilsObjectTagEXT</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
-            <param externsync="pTagInfo.objectHandle">const <type>VkDebugUtilsObjectTagInfoEXT</type>* <name>pTagInfo</name></param>
+            <param externsync="pTagInfo-&gt;objectHandle">const <type>VkDebugUtilsObjectTagInfoEXT</type>* <name>pTagInfo</name></param>
         </command>
         <command>
             <proto><type>void</type> <name>vkQueueBeginDebugUtilsLabelEXT</name></proto>
@@ -10990,7 +11007,7 @@ typedef void <name>CAMetalLayer</name>;
                 <command name="vkSubmitDebugUtilsMessageEXT"/>
             </require>
         </extension>
-        <extension name="VK_ANDROID_external_memory_android_hardware_buffer" number="130" type="device" author="ANDROID" requires="VK_KHR_sampler_ycbcr_conversion,VK_KHR_external_memory,VK_EXT_queue_family_foreign" platform="android" contact="Jesse Hall @critsec" supported="vulkan">
+        <extension name="VK_ANDROID_external_memory_android_hardware_buffer" number="130" type="device" author="ANDROID" requires="VK_KHR_sampler_ycbcr_conversion,VK_KHR_external_memory,VK_EXT_queue_family_foreign,VK_KHR_dedicated_allocation" platform="android" contact="Jesse Hall @critsec" supported="vulkan">
             <require>
                 <enum value="3"                                             name="VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION"/>
                 <enum value="&quot;VK_ANDROID_external_memory_android_hardware_buffer&quot;" name="VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME"/>
@@ -11753,12 +11770,12 @@ typedef void <name>CAMetalLayer</name>;
                 <type name="VkFilterCubicImageViewImageFormatPropertiesEXT"/>
             </require>
         </extension>
-        <extension name="VK_QCOM_extension_172" number="172" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="disabled">
+        <extension name="VK_QCOM_render_pass_shader_resolve" number="172" type="device" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_QCOM_extension_172_SPEC_VERSION"/>
-                <enum value="&quot;VK_QCOM_extension_172&quot;"             name="VK_QCOM_extension_172_EXTENSION_NAME"/>
-                <enum bitpos="2" extends="VkSubpassDescriptionFlagBits"     name="VK_SUBPASS_DESCRIPTION_RESERVED_2_BIT_QCOM"/>
-                <enum bitpos="3" extends="VkSubpassDescriptionFlagBits"     name="VK_SUBPASS_DESCRIPTION_RESERVED_3_BIT_QCOM"/>
+                <enum value="4"                                                 name="VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION"/>
+                <enum value="&quot;VK_QCOM_render_pass_shader_resolve&quot;"    name="VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME"/>
+                <enum bitpos="2" extends="VkSubpassDescriptionFlagBits"         name="VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM"/>
+                <enum bitpos="3" extends="VkSubpassDescriptionFlagBits"         name="VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM"/>
             </require>
         </extension>
         <extension name="VK_QCOM_extension_173" number="173" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="disabled">
@@ -12888,10 +12905,14 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_EXT_extension_286&quot;"              name="VK_EXT_extension_286"/>
             </require>
         </extension>
-        <extension name="VK_NVX_extension_287" number="287" author="NVX" contact="Liam Middlebrook @liam-middlebrook" supported="disabled">
+        <extension name="VK_EXT_robustness2" number="287"  type="device" author="EXT" contact="Liam Middlebrook @liam-middlebrook" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_NVX_EXTENSION_287_SPEC_VERSION"/>
-                <enum value="&quot;VK_NVX_extension_287&quot;"              name="VK_NVX_EXTENSION_287_EXTENSION_NAME"/>
+                <enum value="1"                                                 name="VK_EXT_ROBUSTNESS_2_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_robustness2&quot;"                    name="VK_EXT_ROBUSTNESS_2_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"/>
+                <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"/>
+                <type name="VkPhysicalDeviceRobustness2FeaturesEXT"/>
+                <type name="VkPhysicalDeviceRobustness2PropertiesEXT"/>
             </require>
         </extension>
         <extension name="VK_NVX_extension_288" number="288" author="NVX" contact="Liam Middlebrook @liam-middlebrook" supported="disabled">
@@ -13189,5 +13210,54 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_NV_extension_332&quot;"               name="VK_NV_EXTENSION_332_EXTENSION_NAME"/>
             </require>
         </extension>
+        <extension name="VK_EXT_extension_333" number="333" author="EXT" contact="Matthew Netsch @mnetsch" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_EXT_EXTENSION_333_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_333&quot;"              name="VK_EXT_EXTENSION_333_EXTENSION_NAME"/>
+                <enum bitpos="1"  extends="VkImageViewCreateFlagBits"       name="VK_IMAGE_VIEW_CREATE_RESERVED_1_BIT_EXT"/>
+            </require>
+        </extension>
+        <extension name="VK_EXT_extension_334" number="334" author="EXT" contact="Jeff Leger @jackohound" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_EXT_EXTENSION_334_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_334&quot;"              name="VK_EXT_EXTENSION_334_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_KHR_extension_335" number="335" author="KHR" contact="Mark Bellamy @mark.bellamy_arm" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_KHR_EXTENSION_335_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_extension_335&quot;"              name="VK_KHR_EXTENSION_335_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_EXT_extension_336" number="336" author="EXT" contact="Graeme Leese @gnl21" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_EXT_EXTENSION_336_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_336&quot;"              name="VK_EXT_EXTENSION_336_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_KHR_extension_337" number="337" type="device" author="KHR" contact="Caio Marcelo de Oliveira Filho @cmarcelo" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_KHR_EXTENSION_337_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_extension_337&quot;"              name="VK_KHR_EXTENSION_337_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_KHR_extension_338" number="338" author="KHR" contact="Jeff Leger @jackohound" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_KHR_EXTENSION_338_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_extension_338&quot;"              name="VK_KHR_EXTENSION_338_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_ARM_extension_339" number="339" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_ARM_EXTENSION_339_SPEC_VERSION"/>
+                <enum value="&quot;VK_ARM_extension_339&quot;"              name="VK_ARM_EXTENSION_339_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_EXT_extension_340" number="340" author="EXT" contact="Joshua Ashton @Joshua-Ashton" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_EXT_EXTENSION_340_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_340&quot;"              name="VK_EXT_EXTENSION_340_EXTENSION_NAME"/>
+            </require>
+        </extension>
     </extensions>
 </registry>